Ventana: KBC: Removing the KBC usage on ventana
[linux-2.6.git] / arch / arm / mach-tegra / tegra2_clocks.c
1 /*
2  * arch/arm/mach-tegra/tegra2_clocks.c
3  *
4  * Copyright (C) 2010 Google, Inc.
5  *
6  * Author:
7  *      Colin Cross <ccross@google.com>
8  *
9  * Copyright (C) 2010-2011 NVIDIA Corporation
10  *
11  * This software is licensed under the terms of the GNU General Public
12  * License version 2, as published by the Free Software Foundation, and
13  * may be copied, distributed, and modified under those terms.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  */
21
22 #include <linux/kernel.h>
23 #include <linux/module.h>
24 #include <linux/list.h>
25 #include <linux/spinlock.h>
26 #include <linux/delay.h>
27 #include <linux/io.h>
28 #include <linux/clkdev.h>
29 #include <linux/clk.h>
30 #include <linux/syscore_ops.h>
31 #include <linux/cpufreq.h>
32
33 #include <mach/iomap.h>
34 #include <mach/pinmux.h>
35
36 #include "clock.h"
37 #include "fuse.h"
38 #include "tegra2_emc.h"
39 #include "tegra2_statmon.h"
40
41 #define RST_DEVICES                     0x004
42 #define RST_DEVICES_SET                 0x300
43 #define RST_DEVICES_CLR                 0x304
44 #define RST_DEVICES_NUM                 3
45
46 #define CLK_OUT_ENB                     0x010
47 #define CLK_OUT_ENB_SET                 0x320
48 #define CLK_OUT_ENB_CLR                 0x324
49 #define CLK_OUT_ENB_NUM                 3
50
51 #define CLK_MASK_ARM                    0x44
52 #define MISC_CLK_ENB                    0x48
53
54 #define OSC_CTRL                        0x50
55 #define OSC_CTRL_OSC_FREQ_MASK          (3<<30)
56 #define OSC_CTRL_OSC_FREQ_13MHZ         (0<<30)
57 #define OSC_CTRL_OSC_FREQ_19_2MHZ       (1<<30)
58 #define OSC_CTRL_OSC_FREQ_12MHZ         (2<<30)
59 #define OSC_CTRL_OSC_FREQ_26MHZ         (3<<30)
60 #define OSC_CTRL_MASK                   (0x3f2 | OSC_CTRL_OSC_FREQ_MASK)
61
62 #define OSC_FREQ_DET                    0x58
63 #define OSC_FREQ_DET_TRIG               (1<<31)
64
65 #define OSC_FREQ_DET_STATUS             0x5C
66 #define OSC_FREQ_DET_BUSY               (1<<31)
67 #define OSC_FREQ_DET_CNT_MASK           0xFFFF
68
69 #define PERIPH_CLK_SOURCE_I2S1          0x100
70 #define PERIPH_CLK_SOURCE_EMC           0x19c
71 #define PERIPH_CLK_SOURCE_OSC           0x1fc
72 #define PERIPH_CLK_SOURCE_NUM \
73         ((PERIPH_CLK_SOURCE_OSC - PERIPH_CLK_SOURCE_I2S1) / 4)
74
75 #define PERIPH_CLK_SOURCE_MASK          (3<<30)
76 #define PERIPH_CLK_SOURCE_SHIFT         30
77 #define PERIPH_CLK_SOURCE_ENABLE        (1<<28)
78 #define PERIPH_CLK_SOURCE_DIVU71_MASK   0xFF
79 #define PERIPH_CLK_SOURCE_DIVU16_MASK   0xFFFF
80 #define PERIPH_CLK_SOURCE_DIV_SHIFT     0
81
82 #define SDMMC_CLK_INT_FB_SEL            (1 << 23)
83 #define SDMMC_CLK_INT_FB_DLY_SHIFT      16
84 #define SDMMC_CLK_INT_FB_DLY_MASK       (0xF << SDMMC_CLK_INT_FB_DLY_SHIFT)
85
86 #define PLL_BASE                        0x0
87 #define PLL_BASE_BYPASS                 (1<<31)
88 #define PLL_BASE_ENABLE                 (1<<30)
89 #define PLL_BASE_REF_ENABLE             (1<<29)
90 #define PLL_BASE_OVERRIDE               (1<<28)
91 #define PLL_BASE_DIVP_MASK              (0x7<<20)
92 #define PLL_BASE_DIVP_SHIFT             20
93 #define PLL_BASE_DIVN_MASK              (0x3FF<<8)
94 #define PLL_BASE_DIVN_SHIFT             8
95 #define PLL_BASE_DIVM_MASK              (0x1F)
96 #define PLL_BASE_DIVM_SHIFT             0
97
98 #define PLL_OUT_RATIO_MASK              (0xFF<<8)
99 #define PLL_OUT_RATIO_SHIFT             8
100 #define PLL_OUT_OVERRIDE                (1<<2)
101 #define PLL_OUT_CLKEN                   (1<<1)
102 #define PLL_OUT_RESET_DISABLE           (1<<0)
103
104 #define PLL_MISC(c)                     (((c)->flags & PLL_ALT_MISC_REG) ? 0x4 : 0xc)
105
106 #define PLL_MISC_DCCON_SHIFT            20
107 #define PLL_MISC_CPCON_SHIFT            8
108 #define PLL_MISC_CPCON_MASK             (0xF<<PLL_MISC_CPCON_SHIFT)
109 #define PLL_MISC_LFCON_SHIFT            4
110 #define PLL_MISC_LFCON_MASK             (0xF<<PLL_MISC_LFCON_SHIFT)
111 #define PLL_MISC_VCOCON_SHIFT           0
112 #define PLL_MISC_VCOCON_MASK            (0xF<<PLL_MISC_VCOCON_SHIFT)
113
114 #define PLLU_BASE_POST_DIV              (1<<20)
115
116 #define PLLD_MISC_CLKENABLE             (1<<30)
117 #define PLLD_MISC_DIV_RST               (1<<23)
118 #define PLLD_MISC_DCCON_SHIFT           12
119
120 #define PLLE_MISC_READY                 (1 << 15)
121
122 #define PERIPH_CLK_TO_ENB_REG(c)        ((c->u.periph.clk_num / 32) * 4)
123 #define PERIPH_CLK_TO_ENB_SET_REG(c)    ((c->u.periph.clk_num / 32) * 8)
124 #define PERIPH_CLK_TO_ENB_BIT(c)        (1 << (c->u.periph.clk_num % 32))
125
126 #define SUPER_CLK_MUX                   0x00
127 #define SUPER_STATE_SHIFT               28
128 #define SUPER_STATE_MASK                (0xF << SUPER_STATE_SHIFT)
129 #define SUPER_STATE_STANDBY             (0x0 << SUPER_STATE_SHIFT)
130 #define SUPER_STATE_IDLE                (0x1 << SUPER_STATE_SHIFT)
131 #define SUPER_STATE_RUN                 (0x2 << SUPER_STATE_SHIFT)
132 #define SUPER_STATE_IRQ                 (0x3 << SUPER_STATE_SHIFT)
133 #define SUPER_STATE_FIQ                 (0x4 << SUPER_STATE_SHIFT)
134 #define SUPER_SOURCE_MASK               0xF
135 #define SUPER_FIQ_SOURCE_SHIFT          12
136 #define SUPER_IRQ_SOURCE_SHIFT          8
137 #define SUPER_RUN_SOURCE_SHIFT          4
138 #define SUPER_IDLE_SOURCE_SHIFT         0
139
140 #define SUPER_CLK_DIVIDER               0x04
141
142 #define BUS_CLK_DISABLE                 (1<<3)
143 #define BUS_CLK_DIV_MASK                0x3
144
145 #define PMC_CTRL                        0x0
146  #define PMC_CTRL_BLINK_ENB             (1 << 7)
147
148 #define PMC_DPD_PADS_ORIDE              0x1c
149  #define PMC_DPD_PADS_ORIDE_BLINK_ENB   (1 << 20)
150
151 #define PMC_BLINK_TIMER_DATA_ON_SHIFT   0
152 #define PMC_BLINK_TIMER_DATA_ON_MASK    0x7fff
153 #define PMC_BLINK_TIMER_ENB             (1 << 15)
154 #define PMC_BLINK_TIMER_DATA_OFF_SHIFT  16
155 #define PMC_BLINK_TIMER_DATA_OFF_MASK   0xffff
156
157 static void __iomem *reg_clk_base = IO_ADDRESS(TEGRA_CLK_RESET_BASE);
158 static void __iomem *reg_pmc_base = IO_ADDRESS(TEGRA_PMC_BASE);
159 static void __iomem *misc_gp_hidrev_base = IO_ADDRESS(TEGRA_APB_MISC_BASE);
160
161 #define MISC_GP_HIDREV                  0x804
162
163 static int tegra2_clk_shared_bus_update(struct clk *bus);
164
165 /*
166  * Some clocks share a register with other clocks.  Any clock op that
167  * non-atomically modifies a register used by another clock must lock
168  * clock_register_lock first.
169  */
170 static DEFINE_SPINLOCK(clock_register_lock);
171
172 /*
173  * Some peripheral clocks share an enable bit, so refcount the enable bits
174  * in registers CLK_ENABLE_L, CLK_ENABLE_H, and CLK_ENABLE_U
175  */
176 static int tegra_periph_clk_enable_refcount[3 * 32];
177
178 #define clk_writel(value, reg) \
179         __raw_writel(value, (u32)reg_clk_base + (reg))
180 #define clk_readl(reg) \
181         __raw_readl((u32)reg_clk_base + (reg))
182 #define pmc_writel(value, reg) \
183         __raw_writel(value, (u32)reg_pmc_base + (reg))
184 #define pmc_readl(reg) \
185         __raw_readl((u32)reg_pmc_base + (reg))
186 #define chipid_readl() \
187         __raw_readl((u32)misc_gp_hidrev_base + MISC_GP_HIDREV)
188
189 unsigned long clk_measure_input_freq(void)
190 {
191         u32 clock_autodetect;
192         clk_writel(OSC_FREQ_DET_TRIG | 1, OSC_FREQ_DET);
193         do {} while (clk_readl(OSC_FREQ_DET_STATUS) & OSC_FREQ_DET_BUSY);
194         clock_autodetect = clk_readl(OSC_FREQ_DET_STATUS);
195         if (clock_autodetect >= 732 - 3 && clock_autodetect <= 732 + 3) {
196                 return 12000000;
197         } else if (clock_autodetect >= 794 - 3 && clock_autodetect <= 794 + 3) {
198                 return 13000000;
199         } else if (clock_autodetect >= 1172 - 3 && clock_autodetect <= 1172 + 3) {
200                 return 19200000;
201         } else if (clock_autodetect >= 1587 - 3 && clock_autodetect <= 1587 + 3) {
202                 return 26000000;
203         } else {
204                 pr_err("%s: Unexpected clock autodetect value %d", __func__, clock_autodetect);
205                 BUG();
206                 return 0;
207         }
208 }
209
210 static int clk_div71_get_divider(unsigned long parent_rate, unsigned long rate)
211 {
212         s64 divider_u71 = parent_rate * 2;
213         divider_u71 += rate - 1;
214         do_div(divider_u71, rate);
215
216         if (divider_u71 - 2 < 0)
217                 return 0;
218
219         if (divider_u71 - 2 > 255)
220                 return -EINVAL;
221
222         return divider_u71 - 2;
223 }
224
225 static int clk_div16_get_divider(unsigned long parent_rate, unsigned long rate)
226 {
227         s64 divider_u16;
228
229         divider_u16 = parent_rate;
230         divider_u16 += rate - 1;
231         do_div(divider_u16, rate);
232
233         if (divider_u16 - 1 < 0)
234                 return 0;
235
236         if (divider_u16 - 1 > 0xFFFF)
237                 return -EINVAL;
238
239         return divider_u16 - 1;
240 }
241
242 static inline int clk_set_div(struct clk *c, int n)
243 {
244         return clk_set_rate(c, (clk_get_rate(c->parent) + n-1) / n);
245 }
246
247 /* clk_m functions */
248 static unsigned long tegra2_clk_m_autodetect_rate(struct clk *c)
249 {
250         u32 auto_clock_control = clk_readl(OSC_CTRL) & ~OSC_CTRL_OSC_FREQ_MASK;
251
252         c->rate = clk_measure_input_freq();
253         switch (c->rate) {
254         case 12000000:
255                 auto_clock_control |= OSC_CTRL_OSC_FREQ_12MHZ;
256                 break;
257         case 13000000:
258                 auto_clock_control |= OSC_CTRL_OSC_FREQ_13MHZ;
259                 break;
260         case 19200000:
261                 auto_clock_control |= OSC_CTRL_OSC_FREQ_19_2MHZ;
262                 break;
263         case 26000000:
264                 auto_clock_control |= OSC_CTRL_OSC_FREQ_26MHZ;
265                 break;
266         default:
267                 pr_err("%s: Unexpected clock rate %ld", __func__, c->rate);
268                 BUG();
269         }
270         clk_writel(auto_clock_control, OSC_CTRL);
271         return c->rate;
272 }
273
274 static void tegra2_clk_m_init(struct clk *c)
275 {
276         pr_debug("%s on clock %s\n", __func__, c->name);
277         tegra2_clk_m_autodetect_rate(c);
278 }
279
280 static int tegra2_clk_m_enable(struct clk *c)
281 {
282         pr_debug("%s on clock %s\n", __func__, c->name);
283         return 0;
284 }
285
286 static void tegra2_clk_m_disable(struct clk *c)
287 {
288         pr_debug("%s on clock %s\n", __func__, c->name);
289         BUG();
290 }
291
292 static struct clk_ops tegra_clk_m_ops = {
293         .init           = tegra2_clk_m_init,
294         .enable         = tegra2_clk_m_enable,
295         .disable        = tegra2_clk_m_disable,
296 };
297
298 /* super clock functions */
299 /* "super clocks" on tegra have two-stage muxes and a clock skipping
300  * super divider.  We will ignore the clock skipping divider, since we
301  * can't lower the voltage when using the clock skip, but we can if we
302  * lower the PLL frequency.
303  */
304 static void tegra2_super_clk_init(struct clk *c)
305 {
306         u32 val;
307         int source;
308         int shift;
309         const struct clk_mux_sel *sel;
310         val = clk_readl(c->reg + SUPER_CLK_MUX);
311         c->state = ON;
312         BUG_ON(((val & SUPER_STATE_MASK) != SUPER_STATE_RUN) &&
313                 ((val & SUPER_STATE_MASK) != SUPER_STATE_IDLE));
314         shift = ((val & SUPER_STATE_MASK) == SUPER_STATE_IDLE) ?
315                 SUPER_IDLE_SOURCE_SHIFT : SUPER_RUN_SOURCE_SHIFT;
316         source = (val >> shift) & SUPER_SOURCE_MASK;
317         for (sel = c->inputs; sel->input != NULL; sel++) {
318                 if (sel->value == source)
319                         break;
320         }
321         BUG_ON(sel->input == NULL);
322         c->parent = sel->input;
323 }
324
325 static int tegra2_super_clk_enable(struct clk *c)
326 {
327         clk_writel(0, c->reg + SUPER_CLK_DIVIDER);
328         return 0;
329 }
330
331 static void tegra2_super_clk_disable(struct clk *c)
332 {
333         pr_debug("%s on clock %s\n", __func__, c->name);
334
335         /* oops - don't disable the CPU clock! */
336         BUG();
337 }
338
339 static int tegra2_super_clk_set_parent(struct clk *c, struct clk *p)
340 {
341         u32 val;
342         const struct clk_mux_sel *sel;
343         int shift;
344
345         val = clk_readl(c->reg + SUPER_CLK_MUX);
346         BUG_ON(((val & SUPER_STATE_MASK) != SUPER_STATE_RUN) &&
347                 ((val & SUPER_STATE_MASK) != SUPER_STATE_IDLE));
348         shift = ((val & SUPER_STATE_MASK) == SUPER_STATE_IDLE) ?
349                 SUPER_IDLE_SOURCE_SHIFT : SUPER_RUN_SOURCE_SHIFT;
350         for (sel = c->inputs; sel->input != NULL; sel++) {
351                 if (sel->input == p) {
352                         val &= ~(SUPER_SOURCE_MASK << shift);
353                         val |= sel->value << shift;
354
355                         if (c->refcnt)
356                                 clk_enable(p);
357
358                         clk_writel(val, c->reg);
359
360                         if (c->refcnt && c->parent)
361                                 clk_disable(c->parent);
362
363                         clk_reparent(c, p);
364                         return 0;
365                 }
366         }
367         return -EINVAL;
368 }
369
370 /*
371  * Super clocks have "clock skippers" instead of dividers.  Dividing using
372  * a clock skipper does not allow the voltage to be scaled down, so instead
373  * adjust the rate of the parent clock.  This requires that the parent of a
374  * super clock have no other children, otherwise the rate will change
375  * underneath the other children.
376  */
377 static int tegra2_super_clk_set_rate(struct clk *c, unsigned long rate)
378 {
379         return clk_set_rate(c->parent, rate);
380 }
381
382 static struct clk_ops tegra_super_ops = {
383         .init                   = tegra2_super_clk_init,
384         .enable                 = tegra2_super_clk_enable,
385         .disable                = tegra2_super_clk_disable,
386         .set_parent             = tegra2_super_clk_set_parent,
387         .set_rate               = tegra2_super_clk_set_rate,
388 };
389
390 static int tegra2_twd_clk_set_rate(struct clk *c, unsigned long rate)
391 {
392         /* The input value 'rate' is the clock rate of the CPU complex. */
393         c->rate = (rate * c->mul) / c->div;
394         return 0;
395 }
396
397 static struct clk_ops tegra2_twd_ops = {
398         .set_rate       = tegra2_twd_clk_set_rate,
399 };
400
401 static struct clk tegra2_clk_twd = {
402         /* NOTE: The twd clock must have *NO* parent. It's rate is directly
403                  updated by tegra3_cpu_cmplx_clk_set_rate() because the
404                  frequency change notifer for the twd is called in an
405                  atomic context which cannot take a mutex. */
406         .name     = "twd",
407         .ops      = &tegra2_twd_ops,
408         .max_rate = 1000000000, /* Same as tegra_clk_virtual_cpu.max_rate */
409         .mul      = 1,
410         .div      = 4,
411 };
412
413 /* virtual cpu clock functions */
414 /* some clocks can not be stopped (cpu, memory bus) while the SoC is running.
415    To change the frequency of these clocks, the parent pll may need to be
416    reprogrammed, so the clock must be moved off the pll, the pll reprogrammed,
417    and then the clock moved back to the pll.  To hide this sequence, a virtual
418    clock handles it.
419  */
420 static void tegra2_cpu_clk_init(struct clk *c)
421 {
422 }
423
424 static int tegra2_cpu_clk_enable(struct clk *c)
425 {
426         return 0;
427 }
428
429 static void tegra2_cpu_clk_disable(struct clk *c)
430 {
431         pr_debug("%s on clock %s\n", __func__, c->name);
432
433         /* oops - don't disable the CPU clock! */
434         BUG();
435 }
436
437 static int tegra2_cpu_clk_set_rate(struct clk *c, unsigned long rate)
438 {
439         int ret;
440         /*
441          * Take an extra reference to the main pll so it doesn't turn
442          * off when we move the cpu off of it
443          */
444         clk_enable(c->u.cpu.main);
445
446         ret = clk_set_parent(c->parent, c->u.cpu.backup);
447         if (ret) {
448                 pr_err("Failed to switch cpu to clock %s\n", c->u.cpu.backup->name);
449                 goto out;
450         }
451
452         if (rate == clk_get_rate(c->u.cpu.backup))
453                 goto out;
454
455         ret = clk_set_rate(c->u.cpu.main, rate);
456         if (ret) {
457                 pr_err("Failed to change cpu pll to %lu\n", rate);
458                 goto out;
459         }
460
461         ret = clk_set_parent(c->parent, c->u.cpu.main);
462         if (ret) {
463                 pr_err("Failed to switch cpu to clock %s\n", c->u.cpu.main->name);
464                 goto out;
465         }
466
467         /* We can't parent the twd to directly to the CPU complex because
468            the TWD frequency update notifier is called in an atomic context
469            and the CPU frequency update requires a mutex. Update the twd
470            clock rate with the new CPU complex rate. */
471         clk_set_rate(&tegra2_clk_twd, clk_get_rate_locked(c));
472
473 out:
474         clk_disable(c->u.cpu.main);
475         return ret;
476 }
477
478 static struct clk_ops tegra_cpu_ops = {
479         .init     = tegra2_cpu_clk_init,
480         .enable   = tegra2_cpu_clk_enable,
481         .disable  = tegra2_cpu_clk_disable,
482         .set_rate = tegra2_cpu_clk_set_rate,
483 };
484
485 static void tegra2_virtual_sclk_init(struct clk *c)
486 {
487         c->max_rate = c->parent->max_rate;
488         c->min_rate = c->parent->min_rate;
489 }
490
491 static long tegra2_virtual_sclk_round_rate(struct clk *c, unsigned long rate)
492 {
493         long new_rate = rate;
494         return new_rate;
495 }
496
497 static int tegra2_virtual_sclk_set_rate(struct clk *c, unsigned long rate)
498 {
499         int ret;
500
501         if (rate >= c->u.system.pclk->min_rate * 2) {
502                 ret = clk_set_div(c->u.system.pclk, 2);
503                 if (ret) {
504                         pr_err("Failed to set 1 : 2 pclk divider\n");
505                         return ret;
506                 }
507         }
508
509         ret = clk_set_rate(c->parent, rate);
510         if (ret) {
511                 pr_err("Failed to set sclk source %s to %lu\n",
512                         c->parent->name, rate);
513                 return ret;
514         }
515
516         if (rate < c->u.system.pclk->min_rate * 2) {
517                 ret = clk_set_div(c->u.system.pclk, 1);
518                 if (ret) {
519                         pr_err("Failed to set 1 : 1 pclk divider\n");
520                         return ret;
521                 }
522         }
523
524         return 0;
525 }
526
527 static struct clk_ops tegra_virtual_sclk_ops = {
528         .init = tegra2_virtual_sclk_init,
529         .set_rate = tegra2_virtual_sclk_set_rate,
530         .round_rate = tegra2_virtual_sclk_round_rate,
531         .shared_bus_update = tegra2_clk_shared_bus_update,
532 };
533
534 /* virtual cop clock functions. Used to acquire the fake 'cop' clock to
535  * reset the COP block (i.e. AVP) */
536 static void tegra2_cop_clk_reset(struct clk *c, bool assert)
537 {
538         unsigned long reg = assert ? RST_DEVICES_SET : RST_DEVICES_CLR;
539
540         pr_debug("%s %s\n", __func__, assert ? "assert" : "deassert");
541         clk_writel(1 << 1, reg);
542 }
543
544 static struct clk_ops tegra_cop_ops = {
545         .reset    = tegra2_cop_clk_reset,
546 };
547
548 /* bus clock functions */
549 static void tegra2_bus_clk_init(struct clk *c)
550 {
551         u32 val = clk_readl(c->reg);
552         c->state = ((val >> c->reg_shift) & BUS_CLK_DISABLE) ? OFF : ON;
553         c->div = ((val >> c->reg_shift) & BUS_CLK_DIV_MASK) + 1;
554         c->mul = 1;
555 }
556
557 static int tegra2_bus_clk_enable(struct clk *c)
558 {
559         u32 val;
560         unsigned long flags;
561
562         spin_lock_irqsave(&clock_register_lock, flags);
563
564         val = clk_readl(c->reg);
565         val &= ~(BUS_CLK_DISABLE << c->reg_shift);
566         clk_writel(val, c->reg);
567
568         spin_unlock_irqrestore(&clock_register_lock, flags);
569
570         return 0;
571 }
572
573 static void tegra2_bus_clk_disable(struct clk *c)
574 {
575         u32 val;
576         unsigned long flags;
577
578         spin_lock_irqsave(&clock_register_lock, flags);
579
580         val = clk_readl(c->reg);
581         val |= BUS_CLK_DISABLE << c->reg_shift;
582         clk_writel(val, c->reg);
583
584         spin_unlock_irqrestore(&clock_register_lock, flags);
585 }
586
587 static int tegra2_bus_clk_set_rate(struct clk *c, unsigned long rate)
588 {
589         u32 val;
590         unsigned long parent_rate = clk_get_rate(c->parent);
591         unsigned long flags;
592         int ret = -EINVAL;
593         int i;
594
595         spin_lock_irqsave(&clock_register_lock, flags);
596
597         val = clk_readl(c->reg);
598         for (i = 1; i <= 4; i++) {
599                 if (rate == parent_rate / i) {
600                         val &= ~(BUS_CLK_DIV_MASK << c->reg_shift);
601                         val |= (i - 1) << c->reg_shift;
602                         clk_writel(val, c->reg);
603                         c->div = i;
604                         c->mul = 1;
605                         ret = 0;
606                         break;
607                 }
608         }
609
610         spin_unlock_irqrestore(&clock_register_lock, flags);
611
612         return ret;
613 }
614
615 static struct clk_ops tegra_bus_ops = {
616         .init                   = tegra2_bus_clk_init,
617         .enable                 = tegra2_bus_clk_enable,
618         .disable                = tegra2_bus_clk_disable,
619         .set_rate               = tegra2_bus_clk_set_rate,
620 };
621
622 /* Blink output functions */
623
624 static void tegra2_blink_clk_init(struct clk *c)
625 {
626         u32 val;
627
628         val = pmc_readl(PMC_CTRL);
629         c->state = (val & PMC_CTRL_BLINK_ENB) ? ON : OFF;
630         c->mul = 1;
631         val = pmc_readl(c->reg);
632
633         if (val & PMC_BLINK_TIMER_ENB) {
634                 unsigned int on_off;
635
636                 on_off = (val >> PMC_BLINK_TIMER_DATA_ON_SHIFT) &
637                         PMC_BLINK_TIMER_DATA_ON_MASK;
638                 val >>= PMC_BLINK_TIMER_DATA_OFF_SHIFT;
639                 val &= PMC_BLINK_TIMER_DATA_OFF_MASK;
640                 on_off += val;
641                 /* each tick in the blink timer is 4 32KHz clocks */
642                 c->div = on_off * 4;
643         } else {
644                 c->div = 1;
645         }
646 }
647
648 static int tegra2_blink_clk_enable(struct clk *c)
649 {
650         u32 val;
651
652         val = pmc_readl(PMC_DPD_PADS_ORIDE);
653         pmc_writel(val | PMC_DPD_PADS_ORIDE_BLINK_ENB, PMC_DPD_PADS_ORIDE);
654
655         val = pmc_readl(PMC_CTRL);
656         pmc_writel(val | PMC_CTRL_BLINK_ENB, PMC_CTRL);
657
658         return 0;
659 }
660
661 static void tegra2_blink_clk_disable(struct clk *c)
662 {
663         u32 val;
664
665         val = pmc_readl(PMC_CTRL);
666         pmc_writel(val & ~PMC_CTRL_BLINK_ENB, PMC_CTRL);
667
668         val = pmc_readl(PMC_DPD_PADS_ORIDE);
669         pmc_writel(val & ~PMC_DPD_PADS_ORIDE_BLINK_ENB, PMC_DPD_PADS_ORIDE);
670 }
671
672 static int tegra2_blink_clk_set_rate(struct clk *c, unsigned long rate)
673 {
674         unsigned long parent_rate = clk_get_rate(c->parent);
675         if (rate >= parent_rate) {
676                 c->div = 1;
677                 pmc_writel(0, c->reg);
678         } else {
679                 unsigned int on_off;
680                 u32 val;
681
682                 on_off = DIV_ROUND_UP(parent_rate / 8, rate);
683                 c->div = on_off * 8;
684
685                 val = (on_off & PMC_BLINK_TIMER_DATA_ON_MASK) <<
686                         PMC_BLINK_TIMER_DATA_ON_SHIFT;
687                 on_off &= PMC_BLINK_TIMER_DATA_OFF_MASK;
688                 on_off <<= PMC_BLINK_TIMER_DATA_OFF_SHIFT;
689                 val |= on_off;
690                 val |= PMC_BLINK_TIMER_ENB;
691                 pmc_writel(val, c->reg);
692         }
693
694         return 0;
695 }
696
697 static struct clk_ops tegra_blink_clk_ops = {
698         .init                   = &tegra2_blink_clk_init,
699         .enable                 = &tegra2_blink_clk_enable,
700         .disable                = &tegra2_blink_clk_disable,
701         .set_rate               = &tegra2_blink_clk_set_rate,
702 };
703
704 /* PLL Functions */
705 static int tegra2_pll_clk_wait_for_lock(struct clk *c)
706 {
707         udelay(c->u.pll.lock_delay);
708
709         return 0;
710 }
711
712 static void tegra2_pll_clk_init(struct clk *c)
713 {
714         u32 val = clk_readl(c->reg + PLL_BASE);
715
716         c->state = (val & PLL_BASE_ENABLE) ? ON : OFF;
717
718         if (c->flags & PLL_FIXED && !(val & PLL_BASE_OVERRIDE)) {
719                 pr_warning("Clock %s has unknown fixed frequency\n", c->name);
720                 c->mul = 1;
721                 c->div = 1;
722         } else if (val & PLL_BASE_BYPASS) {
723                 c->mul = 1;
724                 c->div = 1;
725         } else {
726                 c->mul = (val & PLL_BASE_DIVN_MASK) >> PLL_BASE_DIVN_SHIFT;
727                 c->div = (val & PLL_BASE_DIVM_MASK) >> PLL_BASE_DIVM_SHIFT;
728                 if (c->flags & PLLU)
729                         c->div *= (val & PLLU_BASE_POST_DIV) ? 1 : 2;
730                 else
731                         c->div *= (val & PLL_BASE_DIVP_MASK) ? 2 : 1;
732         }
733 }
734
735 static int tegra2_pll_clk_enable(struct clk *c)
736 {
737         u32 val;
738         pr_debug("%s on clock %s\n", __func__, c->name);
739
740         val = clk_readl(c->reg + PLL_BASE);
741         val &= ~PLL_BASE_BYPASS;
742         val |= PLL_BASE_ENABLE;
743         clk_writel(val, c->reg + PLL_BASE);
744
745         if (c->flags & PLLD) {
746                 val = clk_readl(c->reg + PLL_MISC(c) + PLL_BASE);
747                 val |= PLLD_MISC_CLKENABLE;
748                 clk_writel(val, c->reg + PLL_MISC(c) + PLL_BASE);
749         }
750
751         tegra2_pll_clk_wait_for_lock(c);
752
753         return 0;
754 }
755
756 static void tegra2_pll_clk_disable(struct clk *c)
757 {
758         u32 val;
759         pr_debug("%s on clock %s\n", __func__, c->name);
760
761         val = clk_readl(c->reg);
762         val &= ~(PLL_BASE_BYPASS | PLL_BASE_ENABLE);
763         clk_writel(val, c->reg);
764
765         if (c->flags & PLLD) {
766                 val = clk_readl(c->reg + PLL_MISC(c) + PLL_BASE);
767                 val &= ~PLLD_MISC_CLKENABLE;
768                 clk_writel(val, c->reg + PLL_MISC(c) + PLL_BASE);
769         }
770 }
771
772 static int tegra2_pll_clk_set_rate(struct clk *c, unsigned long rate)
773 {
774         u32 val;
775         unsigned long input_rate;
776         const struct clk_pll_freq_table *sel;
777
778         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
779
780         input_rate = clk_get_rate(c->parent);
781         for (sel = c->u.pll.freq_table; sel->input_rate != 0; sel++) {
782                 if (sel->input_rate == input_rate && sel->output_rate == rate) {
783                         c->mul = sel->n;
784                         c->div = sel->m * sel->p;
785
786                         val = clk_readl(c->reg + PLL_BASE);
787                         if (c->flags & PLL_FIXED)
788                                 val |= PLL_BASE_OVERRIDE;
789                         val &= ~(PLL_BASE_DIVP_MASK | PLL_BASE_DIVN_MASK |
790                                  PLL_BASE_DIVM_MASK);
791                         val |= (sel->m << PLL_BASE_DIVM_SHIFT) |
792                                 (sel->n << PLL_BASE_DIVN_SHIFT);
793                         BUG_ON(sel->p < 1 || sel->p > 128);
794                         if (c->flags & PLLU) {
795                                 if (sel->p == 1)
796                                         val |= PLLU_BASE_POST_DIV;
797                         } else {
798                                 if (sel->p == 2)
799                                         val |= 1 << PLL_BASE_DIVP_SHIFT;
800                                 else if (sel->p == 4)
801                                         val |= 2 << PLL_BASE_DIVP_SHIFT;
802                                 else if (sel->p == 8)
803                                         val |= 3 << PLL_BASE_DIVP_SHIFT;
804                                 else if (sel->p == 16)
805                                         val |= 4 << PLL_BASE_DIVP_SHIFT;
806                                 else if (sel->p == 32)
807                                         val |= 5 << PLL_BASE_DIVP_SHIFT;
808                                 else if (sel->p == 64)
809                                         val |= 6 << PLL_BASE_DIVP_SHIFT;
810                                 else if (sel->p == 128)
811                                         val |= 7 << PLL_BASE_DIVP_SHIFT;
812                         }
813                         clk_writel(val, c->reg + PLL_BASE);
814
815                         if (c->flags & PLL_HAS_CPCON) {
816                                 val = clk_readl(c->reg + PLL_MISC(c));
817                                 val &= ~PLL_MISC_CPCON_MASK;
818                                 val |= sel->cpcon << PLL_MISC_CPCON_SHIFT;
819                                 clk_writel(val, c->reg + PLL_MISC(c));
820                         }
821
822                         if (c->state == ON)
823                                 tegra2_pll_clk_enable(c);
824
825                         return 0;
826                 }
827         }
828         return -EINVAL;
829 }
830
831 static struct clk_ops tegra_pll_ops = {
832         .init                   = tegra2_pll_clk_init,
833         .enable                 = tegra2_pll_clk_enable,
834         .disable                = tegra2_pll_clk_disable,
835         .set_rate               = tegra2_pll_clk_set_rate,
836 };
837
838 static int tegra2_plle_clk_enable(struct clk *c)
839 {
840         u32 val;
841
842         pr_debug("%s on clock %s\n", __func__, c->name);
843
844         mdelay(1);
845
846         val = clk_readl(c->reg + PLL_BASE);
847         if (!(val & PLLE_MISC_READY))
848                 return -EBUSY;
849
850         val = clk_readl(c->reg + PLL_BASE);
851         val |= PLL_BASE_ENABLE | PLL_BASE_BYPASS;
852         clk_writel(val, c->reg + PLL_BASE);
853
854         return 0;
855 }
856
857 static struct clk_ops tegra_plle_ops = {
858         .init       = tegra2_pll_clk_init,
859         .enable     = tegra2_plle_clk_enable,
860         .set_rate   = tegra2_pll_clk_set_rate,
861 };
862
863 /* Clock divider ops */
864 static void tegra2_pll_div_clk_init(struct clk *c)
865 {
866         u32 val = clk_readl(c->reg);
867         u32 divu71;
868         val >>= c->reg_shift;
869         c->state = (val & PLL_OUT_CLKEN) ? ON : OFF;
870         if (!(val & PLL_OUT_RESET_DISABLE))
871                 c->state = OFF;
872
873         if (c->flags & DIV_U71) {
874                 divu71 = (val & PLL_OUT_RATIO_MASK) >> PLL_OUT_RATIO_SHIFT;
875                 c->div = (divu71 + 2);
876                 c->mul = 2;
877         } else if (c->flags & DIV_2) {
878                 c->div = 2;
879                 c->mul = 1;
880         } else {
881                 c->div = 1;
882                 c->mul = 1;
883         }
884 }
885
886 static int tegra2_pll_div_clk_enable(struct clk *c)
887 {
888         u32 val;
889         u32 new_val;
890         unsigned long flags;
891
892         pr_debug("%s: %s\n", __func__, c->name);
893         if (c->flags & DIV_U71) {
894                 spin_lock_irqsave(&clock_register_lock, flags);
895                 val = clk_readl(c->reg);
896                 new_val = val >> c->reg_shift;
897                 new_val &= 0xFFFF;
898
899                 new_val |= PLL_OUT_CLKEN | PLL_OUT_RESET_DISABLE;
900
901                 val &= ~(0xFFFF << c->reg_shift);
902                 val |= new_val << c->reg_shift;
903                 clk_writel(val, c->reg);
904                 spin_unlock_irqrestore(&clock_register_lock, flags);
905                 return 0;
906         } else if (c->flags & DIV_2) {
907                 BUG_ON(!(c->flags & PLLD));
908                 spin_lock_irqsave(&clock_register_lock, flags);
909                 val = clk_readl(c->reg);
910                 val &= ~PLLD_MISC_DIV_RST;
911                 clk_writel(val, c->reg);
912                 spin_unlock_irqrestore(&clock_register_lock, flags);
913                 return 0;
914         }
915         return -EINVAL;
916 }
917
918 static void tegra2_pll_div_clk_disable(struct clk *c)
919 {
920         u32 val;
921         u32 new_val;
922         unsigned long flags;
923
924         pr_debug("%s: %s\n", __func__, c->name);
925         if (c->flags & DIV_U71) {
926                 spin_lock_irqsave(&clock_register_lock, flags);
927                 val = clk_readl(c->reg);
928                 new_val = val >> c->reg_shift;
929                 new_val &= 0xFFFF;
930
931                 new_val &= ~(PLL_OUT_CLKEN | PLL_OUT_RESET_DISABLE);
932
933                 val &= ~(0xFFFF << c->reg_shift);
934                 val |= new_val << c->reg_shift;
935                 clk_writel(val, c->reg);
936                 spin_unlock_irqrestore(&clock_register_lock, flags);
937         } else if (c->flags & DIV_2) {
938                 BUG_ON(!(c->flags & PLLD));
939                 spin_lock_irqsave(&clock_register_lock, flags);
940                 val = clk_readl(c->reg);
941                 val |= PLLD_MISC_DIV_RST;
942                 clk_writel(val, c->reg);
943                 spin_unlock_irqrestore(&clock_register_lock, flags);
944         }
945 }
946
947 static int tegra2_pll_div_clk_set_rate(struct clk *c, unsigned long rate)
948 {
949         u32 val;
950         u32 new_val;
951         int divider_u71;
952         unsigned long parent_rate = clk_get_rate(c->parent);
953         unsigned long flags;
954
955         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
956         if (c->flags & DIV_U71) {
957                 divider_u71 = clk_div71_get_divider(parent_rate, rate);
958                 if (divider_u71 >= 0) {
959                         spin_lock_irqsave(&clock_register_lock, flags);
960                         val = clk_readl(c->reg);
961                         new_val = val >> c->reg_shift;
962                         new_val &= 0xFFFF;
963                         if (c->flags & DIV_U71_FIXED)
964                                 new_val |= PLL_OUT_OVERRIDE;
965                         new_val &= ~PLL_OUT_RATIO_MASK;
966                         new_val |= divider_u71 << PLL_OUT_RATIO_SHIFT;
967
968                         val &= ~(0xFFFF << c->reg_shift);
969                         val |= new_val << c->reg_shift;
970                         clk_writel(val, c->reg);
971                         c->div = divider_u71 + 2;
972                         c->mul = 2;
973                         spin_unlock_irqrestore(&clock_register_lock, flags);
974                         return 0;
975                 }
976         } else if (c->flags & DIV_2) {
977                 if (parent_rate == rate * 2)
978                         return 0;
979         }
980         return -EINVAL;
981 }
982
983 static long tegra2_pll_div_clk_round_rate(struct clk *c, unsigned long rate)
984 {
985         int divider;
986         unsigned long parent_rate = clk_get_rate(c->parent);
987         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
988
989         if (c->flags & DIV_U71) {
990                 divider = clk_div71_get_divider(parent_rate, rate);
991                 if (divider < 0)
992                         return divider;
993                 return DIV_ROUND_UP(parent_rate * 2, divider + 2);
994         } else if (c->flags & DIV_2) {
995                 return DIV_ROUND_UP(parent_rate, 2);
996         }
997         return -EINVAL;
998 }
999
1000 static struct clk_ops tegra_pll_div_ops = {
1001         .init                   = tegra2_pll_div_clk_init,
1002         .enable                 = tegra2_pll_div_clk_enable,
1003         .disable                = tegra2_pll_div_clk_disable,
1004         .set_rate               = tegra2_pll_div_clk_set_rate,
1005         .round_rate             = tegra2_pll_div_clk_round_rate,
1006 };
1007
1008 /* Periph clk ops */
1009
1010 static void tegra2_periph_clk_init(struct clk *c)
1011 {
1012         u32 val = clk_readl(c->reg);
1013         const struct clk_mux_sel *mux = 0;
1014         const struct clk_mux_sel *sel;
1015         if (c->flags & MUX) {
1016                 for (sel = c->inputs; sel->input != NULL; sel++) {
1017                         if (val >> PERIPH_CLK_SOURCE_SHIFT == sel->value)
1018                                 mux = sel;
1019                 }
1020                 BUG_ON(!mux);
1021
1022                 c->parent = mux->input;
1023         } else {
1024                 c->parent = c->inputs[0].input;
1025         }
1026
1027         if (c->flags & DIV_U71) {
1028                 u32 divu71 = val & PERIPH_CLK_SOURCE_DIVU71_MASK;
1029                 c->div = divu71 + 2;
1030                 c->mul = 2;
1031         } else if (c->flags & DIV_U16) {
1032                 u32 divu16 = val & PERIPH_CLK_SOURCE_DIVU16_MASK;
1033                 c->div = divu16 + 1;
1034                 c->mul = 1;
1035         } else {
1036                 c->div = 1;
1037                 c->mul = 1;
1038         }
1039
1040         c->state = ON;
1041
1042         if (!c->u.periph.clk_num)
1043                 return;
1044
1045         if (!(clk_readl(CLK_OUT_ENB + PERIPH_CLK_TO_ENB_REG(c)) &
1046                         PERIPH_CLK_TO_ENB_BIT(c)))
1047                 c->state = OFF;
1048
1049         if (!(c->flags & PERIPH_NO_RESET))
1050                 if (clk_readl(RST_DEVICES + PERIPH_CLK_TO_ENB_REG(c)) &
1051                                 PERIPH_CLK_TO_ENB_BIT(c))
1052                         c->state = OFF;
1053 }
1054
1055 static int tegra2_periph_clk_enable(struct clk *c)
1056 {
1057         u32 val;
1058         unsigned long flags;
1059         int refcount;
1060         pr_debug("%s on clock %s\n", __func__, c->name);
1061
1062         if (!c->u.periph.clk_num)
1063                 return 0;
1064
1065         spin_lock_irqsave(&clock_register_lock, flags);
1066
1067         refcount = tegra_periph_clk_enable_refcount[c->u.periph.clk_num]++;
1068
1069         if (refcount > 1)
1070                 goto out;
1071
1072         clk_writel(PERIPH_CLK_TO_ENB_BIT(c),
1073                 CLK_OUT_ENB_SET + PERIPH_CLK_TO_ENB_SET_REG(c));
1074         if (!(c->flags & PERIPH_NO_RESET) && !(c->flags & PERIPH_MANUAL_RESET))
1075                 clk_writel(PERIPH_CLK_TO_ENB_BIT(c),
1076                         RST_DEVICES_CLR + PERIPH_CLK_TO_ENB_SET_REG(c));
1077         if (c->flags & PERIPH_EMC_ENB) {
1078                 /* The EMC peripheral clock has 2 extra enable bits */
1079                 /* FIXME: Do they need to be disabled? */
1080                 val = clk_readl(c->reg);
1081                 val |= 0x3 << 24;
1082                 clk_writel(val, c->reg);
1083         }
1084
1085 out:
1086         spin_unlock_irqrestore(&clock_register_lock, flags);
1087
1088         return 0;
1089 }
1090
1091 static void tegra2_periph_clk_disable(struct clk *c)
1092 {
1093         unsigned long flags;
1094         unsigned long val;
1095
1096         pr_debug("%s on clock %s\n", __func__, c->name);
1097
1098         if (!c->u.periph.clk_num)
1099                 return;
1100
1101         spin_lock_irqsave(&clock_register_lock, flags);
1102
1103         if (c->refcnt)
1104                 tegra_periph_clk_enable_refcount[c->u.periph.clk_num]--;
1105
1106         if (tegra_periph_clk_enable_refcount[c->u.periph.clk_num] == 0) {
1107                 /* If peripheral is in the APB bus then read the APB bus to
1108                  * flush the write operation in apb bus. This will avoid the
1109                  * peripheral access after disabling clock*/
1110                 if (c->flags & PERIPH_ON_APB)
1111                         val = chipid_readl();
1112
1113                 clk_writel(PERIPH_CLK_TO_ENB_BIT(c),
1114                         CLK_OUT_ENB_CLR + PERIPH_CLK_TO_ENB_SET_REG(c));
1115         }
1116
1117         spin_unlock_irqrestore(&clock_register_lock, flags);
1118 }
1119
1120 static void tegra2_periph_clk_reset(struct clk *c, bool assert)
1121 {
1122         unsigned long base = assert ? RST_DEVICES_SET : RST_DEVICES_CLR;
1123         unsigned long val;
1124
1125         pr_debug("%s %s on clock %s\n", __func__,
1126                  assert ? "assert" : "deassert", c->name);
1127
1128         BUG_ON(!c->u.periph.clk_num);
1129
1130         if (!(c->flags & PERIPH_NO_RESET)) {
1131                 /* If peripheral is in the APB bus then read the APB bus to
1132                  * flush the write operation in apb bus. This will avoid the
1133                  * peripheral access after disabling clock*/
1134                 if (c->flags & PERIPH_ON_APB)
1135                         val = chipid_readl();
1136
1137                 clk_writel(PERIPH_CLK_TO_ENB_BIT(c),
1138                            base + PERIPH_CLK_TO_ENB_SET_REG(c));
1139         }
1140 }
1141
1142 static int tegra2_periph_clk_set_parent(struct clk *c, struct clk *p)
1143 {
1144         u32 val;
1145         const struct clk_mux_sel *sel;
1146         pr_debug("%s: %s %s\n", __func__, c->name, p->name);
1147         for (sel = c->inputs; sel->input != NULL; sel++) {
1148                 if (sel->input == p) {
1149                         val = clk_readl(c->reg);
1150                         val &= ~((c->reg_shift >> 8) << (c->reg_shift & 0xFF));
1151                         val |= (sel->value) << (c->reg_shift & 0xFF);
1152
1153                         if (c->refcnt)
1154                                 clk_enable(p);
1155
1156                         clk_writel(val, c->reg);
1157
1158                         if (c->refcnt && c->parent)
1159                                 clk_disable(c->parent);
1160
1161                         clk_reparent(c, p);
1162                         return 0;
1163                 }
1164         }
1165
1166         return -EINVAL;
1167 }
1168
1169 static int tegra2_periph_clk_set_rate(struct clk *c, unsigned long rate)
1170 {
1171         u32 val;
1172         int divider;
1173         unsigned long parent_rate = clk_get_rate(c->parent);
1174
1175         if (c->flags & DIV_U71) {
1176                 divider = clk_div71_get_divider(parent_rate, rate);
1177                 if (divider >= 0) {
1178                         val = clk_readl(c->reg);
1179                         val &= ~PERIPH_CLK_SOURCE_DIVU71_MASK;
1180                         val |= divider;
1181                         clk_writel(val, c->reg);
1182                         c->div = divider + 2;
1183                         c->mul = 2;
1184                         return 0;
1185                 }
1186         } else if (c->flags & DIV_U16) {
1187                 divider = clk_div16_get_divider(parent_rate, rate);
1188                 if (divider >= 0) {
1189                         val = clk_readl(c->reg);
1190                         val &= ~PERIPH_CLK_SOURCE_DIVU16_MASK;
1191                         val |= divider;
1192                         clk_writel(val, c->reg);
1193                         c->div = divider + 1;
1194                         c->mul = 1;
1195                         return 0;
1196                 }
1197         } else if (parent_rate <= rate) {
1198                 c->div = 1;
1199                 c->mul = 1;
1200                 return 0;
1201         }
1202         return -EINVAL;
1203 }
1204
1205 static long tegra2_periph_clk_round_rate(struct clk *c,
1206         unsigned long rate)
1207 {
1208         int divider;
1209         unsigned long parent_rate = clk_get_rate(c->parent);
1210         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
1211
1212         if (c->flags & DIV_U71) {
1213                 divider = clk_div71_get_divider(parent_rate, rate);
1214                 if (divider < 0)
1215                         return divider;
1216
1217                 return DIV_ROUND_UP(parent_rate * 2, divider + 2);
1218         } else if (c->flags & DIV_U16) {
1219                 divider = clk_div16_get_divider(parent_rate, rate);
1220                 if (divider < 0)
1221                         return divider;
1222                 return DIV_ROUND_UP(parent_rate, divider + 1);
1223         }
1224         return -EINVAL;
1225 }
1226
1227 static struct clk_ops tegra_periph_clk_ops = {
1228         .init                   = &tegra2_periph_clk_init,
1229         .enable                 = &tegra2_periph_clk_enable,
1230         .disable                = &tegra2_periph_clk_disable,
1231         .set_parent             = &tegra2_periph_clk_set_parent,
1232         .set_rate               = &tegra2_periph_clk_set_rate,
1233         .round_rate             = &tegra2_periph_clk_round_rate,
1234         .reset                  = &tegra2_periph_clk_reset,
1235 };
1236
1237 /* The SDMMC controllers have extra bits in the clock source register that
1238  * adjust the delay between the clock and data to compenstate for delays
1239  * on the PCB. */
1240 void tegra2_sdmmc_tap_delay(struct clk *c, int delay)
1241 {
1242         u32 reg;
1243
1244         delay = clamp(delay, 0, 15);
1245         reg = clk_readl(c->reg);
1246         reg &= ~SDMMC_CLK_INT_FB_DLY_MASK;
1247         reg |= SDMMC_CLK_INT_FB_SEL;
1248         reg |= delay << SDMMC_CLK_INT_FB_DLY_SHIFT;
1249         clk_writel(reg, c->reg);
1250 }
1251
1252 /* External memory controller clock ops */
1253 static void tegra2_emc_clk_init(struct clk *c)
1254 {
1255         tegra2_periph_clk_init(c);
1256         c->max_rate = clk_get_rate_locked(c);
1257 }
1258
1259 static long tegra2_emc_clk_round_rate(struct clk *c, unsigned long rate)
1260 {
1261         long new_rate = rate;
1262
1263         new_rate = tegra_emc_round_rate(new_rate);
1264         if (new_rate < 0)
1265                 return c->max_rate;
1266
1267         BUG_ON(new_rate != tegra2_periph_clk_round_rate(c, new_rate));
1268
1269         return new_rate;
1270 }
1271
1272 static int tegra2_emc_clk_set_rate(struct clk *c, unsigned long rate)
1273 {
1274         int ret;
1275         /*
1276          * The Tegra2 memory controller has an interlock with the clock
1277          * block that allows memory shadowed registers to be updated,
1278          * and then transfer them to the main registers at the same
1279          * time as the clock update without glitches.
1280          */
1281         ret = tegra_emc_set_rate(rate);
1282         if (ret < 0)
1283                 return ret;
1284
1285         ret = tegra2_periph_clk_set_rate(c, rate);
1286         udelay(1);
1287
1288         return ret;
1289 }
1290
1291 static struct clk_ops tegra_emc_clk_ops = {
1292         .init                   = &tegra2_emc_clk_init,
1293         .enable                 = &tegra2_periph_clk_enable,
1294         .disable                = &tegra2_periph_clk_disable,
1295         .set_parent             = &tegra2_periph_clk_set_parent,
1296         .set_rate               = &tegra2_emc_clk_set_rate,
1297         .round_rate             = &tegra2_emc_clk_round_rate,
1298         .reset                  = &tegra2_periph_clk_reset,
1299         .shared_bus_update      = &tegra2_clk_shared_bus_update,
1300 };
1301
1302 /* Clock doubler ops */
1303 static void tegra2_clk_double_init(struct clk *c)
1304 {
1305         c->mul = 2;
1306         c->div = 1;
1307         c->state = ON;
1308
1309         if (!c->u.periph.clk_num)
1310                 return;
1311
1312         if (!(clk_readl(CLK_OUT_ENB + PERIPH_CLK_TO_ENB_REG(c)) &
1313                         PERIPH_CLK_TO_ENB_BIT(c)))
1314                 c->state = OFF;
1315 };
1316
1317 static int tegra2_clk_double_set_rate(struct clk *c, unsigned long rate)
1318 {
1319         if (rate != 2 * clk_get_rate(c->parent))
1320                 return -EINVAL;
1321         c->mul = 2;
1322         c->div = 1;
1323         return 0;
1324 }
1325
1326 static struct clk_ops tegra_clk_double_ops = {
1327         .init                   = &tegra2_clk_double_init,
1328         .enable                 = &tegra2_periph_clk_enable,
1329         .disable                = &tegra2_periph_clk_disable,
1330         .set_rate               = &tegra2_clk_double_set_rate,
1331 };
1332
1333 /* Audio sync clock ops */
1334 static void tegra2_audio_sync_clk_init(struct clk *c)
1335 {
1336         int source;
1337         const struct clk_mux_sel *sel;
1338         u32 val = clk_readl(c->reg);
1339         c->state = (val & (1<<4)) ? OFF : ON;
1340         source = val & 0xf;
1341         for (sel = c->inputs; sel->input != NULL; sel++)
1342                 if (sel->value == source)
1343                         break;
1344         BUG_ON(sel->input == NULL);
1345         c->parent = sel->input;
1346 }
1347
1348 static int tegra2_audio_sync_clk_enable(struct clk *c)
1349 {
1350         clk_writel(0, c->reg);
1351         return 0;
1352 }
1353
1354 static void tegra2_audio_sync_clk_disable(struct clk *c)
1355 {
1356         clk_writel(1, c->reg);
1357 }
1358
1359 static int tegra2_audio_sync_clk_set_parent(struct clk *c, struct clk *p)
1360 {
1361         u32 val;
1362         const struct clk_mux_sel *sel;
1363         for (sel = c->inputs; sel->input != NULL; sel++) {
1364                 if (sel->input == p) {
1365                         val = clk_readl(c->reg);
1366                         val &= ~0xf;
1367                         val |= sel->value;
1368
1369                         if (c->refcnt)
1370                                 clk_enable(p);
1371
1372                         clk_writel(val, c->reg);
1373
1374                         if (c->refcnt && c->parent)
1375                                 clk_disable(c->parent);
1376
1377                         clk_reparent(c, p);
1378                         return 0;
1379                 }
1380         }
1381
1382         return -EINVAL;
1383 }
1384
1385 static struct clk_ops tegra_audio_sync_clk_ops = {
1386         .init       = tegra2_audio_sync_clk_init,
1387         .enable     = tegra2_audio_sync_clk_enable,
1388         .disable    = tegra2_audio_sync_clk_disable,
1389         .set_parent = tegra2_audio_sync_clk_set_parent,
1390 };
1391
1392 /* call this function after pinmux configuration */
1393 static void tegra2_cdev_clk_set_parent(struct clk *c)
1394 {
1395         const struct clk_mux_sel *mux = 0;
1396         const struct clk_mux_sel *sel;
1397         enum tegra_pingroup pg = TEGRA_PINGROUP_CDEV1;
1398         int val;
1399
1400         /* Get pinmux setting for cdev1 and cdev2 from APB_MISC register */
1401         if (!strcmp(c->name, "clk_dev2"))
1402                 pg = TEGRA_PINGROUP_CDEV2;
1403
1404         val = tegra_pinmux_get_func(pg);
1405         for (sel = c->inputs; sel->input != NULL; sel++) {
1406                 if (val == sel->value)
1407                         mux = sel;
1408         }
1409         BUG_ON(!mux);
1410
1411         c->parent = mux->input;
1412 }
1413
1414 /* cdev1 and cdev2 (dap_mclk1 and dap_mclk2) ops */
1415 static void tegra2_cdev_clk_init(struct clk *c)
1416 {
1417         const struct clk_mux_sel *sel;
1418
1419         /* Find max rate from inputs */
1420         for (sel = c->inputs; sel->input != NULL; sel++) {
1421                 c->max_rate = max(sel->input->max_rate, c->max_rate);
1422         }
1423
1424         /* We could un-tristate the cdev1 or cdev2 pingroup here; this is
1425          * currently done in the pinmux code. */
1426         c->state = ON;
1427
1428         BUG_ON(!c->u.periph.clk_num);
1429
1430         if (!(clk_readl(CLK_OUT_ENB + PERIPH_CLK_TO_ENB_REG(c)) &
1431                         PERIPH_CLK_TO_ENB_BIT(c)))
1432                 c->state = OFF;
1433 }
1434
1435 static int tegra2_cdev_clk_enable(struct clk *c)
1436 {
1437         BUG_ON(!c->u.periph.clk_num);
1438
1439         if (!c->parent) {
1440                 /* Set parent from inputs */
1441                 tegra2_cdev_clk_set_parent(c);
1442                 clk_enable(c->parent);
1443         }
1444
1445         clk_writel(PERIPH_CLK_TO_ENB_BIT(c),
1446                 CLK_OUT_ENB_SET + PERIPH_CLK_TO_ENB_SET_REG(c));
1447         return 0;
1448 }
1449
1450 static void tegra2_cdev_clk_disable(struct clk *c)
1451 {
1452         BUG_ON(!c->u.periph.clk_num);
1453
1454         clk_writel(PERIPH_CLK_TO_ENB_BIT(c),
1455                 CLK_OUT_ENB_CLR + PERIPH_CLK_TO_ENB_SET_REG(c));
1456 }
1457
1458 static struct clk_ops tegra_cdev_clk_ops = {
1459         .init                   = &tegra2_cdev_clk_init,
1460         .enable                 = &tegra2_cdev_clk_enable,
1461         .disable                = &tegra2_cdev_clk_disable,
1462 };
1463
1464 /* shared bus ops */
1465 /*
1466  * Some clocks may have multiple downstream users that need to request a
1467  * higher clock rate.  Shared bus clocks provide a unique shared_bus_user
1468  * clock to each user.  The frequency of the bus is set to the highest
1469  * enabled shared_bus_user clock, with a minimum value set by the
1470  * shared bus.
1471  */
1472 static int tegra2_clk_shared_bus_update(struct clk *bus)
1473 {
1474         struct clk *c;
1475         unsigned long rate = bus->min_rate;
1476
1477         list_for_each_entry(c, &bus->shared_bus_list, u.shared_bus_user.node)
1478                 if (c->u.shared_bus_user.enabled)
1479                         rate = max(c->u.shared_bus_user.rate, rate);
1480
1481         if (rate == clk_get_rate_locked(bus))
1482                 return 0;
1483
1484         return clk_set_rate_locked(bus, rate);
1485 };
1486
1487 static void tegra_clk_shared_bus_init(struct clk *c)
1488 {
1489         unsigned long flags;
1490
1491         c->max_rate = c->parent->max_rate;
1492         c->u.shared_bus_user.rate = c->parent->max_rate;
1493         c->state = OFF;
1494         c->set = true;
1495
1496         clk_lock_save(c->parent, &flags);
1497
1498         list_add_tail(&c->u.shared_bus_user.node,
1499                 &c->parent->shared_bus_list);
1500
1501         clk_unlock_restore(c->parent, &flags);
1502 }
1503
1504 static int tegra_clk_shared_bus_set_rate(struct clk *c, unsigned long rate)
1505 {
1506         unsigned long flags;
1507         int ret;
1508         long new_rate = rate;
1509
1510         new_rate = clk_round_rate(c->parent, new_rate);
1511         if (new_rate < 0)
1512                 return new_rate;
1513
1514         clk_lock_save(c->parent, &flags);
1515
1516         c->u.shared_bus_user.rate = new_rate;
1517         ret = tegra_clk_shared_bus_update(c->parent);
1518
1519         clk_unlock_restore(c->parent, &flags);
1520
1521         return ret;
1522 }
1523
1524 static long tegra_clk_shared_bus_round_rate(struct clk *c, unsigned long rate)
1525 {
1526         return clk_round_rate(c->parent, rate);
1527 }
1528
1529 static int tegra_clk_shared_bus_enable(struct clk *c)
1530 {
1531         unsigned long flags;
1532         int ret;
1533
1534         clk_lock_save(c->parent, &flags);
1535
1536         c->u.shared_bus_user.enabled = true;
1537         ret = tegra_clk_shared_bus_update(c->parent);
1538         if (strcmp(c->name, "avp.sclk") == 0)
1539                 tegra2_statmon_start();
1540
1541         clk_unlock_restore(c->parent, &flags);
1542
1543         return ret;
1544 }
1545
1546 static void tegra_clk_shared_bus_disable(struct clk *c)
1547 {
1548         unsigned long flags;
1549         int ret;
1550
1551         clk_lock_save(c->parent, &flags);
1552
1553         if (strcmp(c->name, "avp.sclk") == 0)
1554                 tegra2_statmon_stop();
1555         c->u.shared_bus_user.enabled = false;
1556         ret = tegra_clk_shared_bus_update(c->parent);
1557         WARN_ON_ONCE(ret);
1558
1559         clk_unlock_restore(c->parent, &flags);
1560 }
1561
1562 static struct clk_ops tegra_clk_shared_bus_ops = {
1563         .init = tegra_clk_shared_bus_init,
1564         .enable = tegra_clk_shared_bus_enable,
1565         .disable = tegra_clk_shared_bus_disable,
1566         .set_rate = tegra_clk_shared_bus_set_rate,
1567         .round_rate = tegra_clk_shared_bus_round_rate,
1568 };
1569
1570
1571 /* Clock definitions */
1572 static struct clk tegra_clk_32k = {
1573         .name = "clk_32k",
1574         .rate = 32768,
1575         .ops  = NULL,
1576         .max_rate = 32768,
1577 };
1578
1579 static struct clk_pll_freq_table tegra_pll_s_freq_table[] = {
1580         {32768, 12000000, 366, 1, 1, 0},
1581         {32768, 13000000, 397, 1, 1, 0},
1582         {32768, 19200000, 586, 1, 1, 0},
1583         {32768, 26000000, 793, 1, 1, 0},
1584         {0, 0, 0, 0, 0, 0},
1585 };
1586
1587 static struct clk tegra_pll_s = {
1588         .name      = "pll_s",
1589         .flags     = PLL_ALT_MISC_REG,
1590         .ops       = &tegra_pll_ops,
1591         .parent    = &tegra_clk_32k,
1592         .max_rate  = 26000000,
1593         .reg       = 0xf0,
1594         .u.pll = {
1595                 .input_min = 32768,
1596                 .input_max = 32768,
1597                 .cf_min    = 0, /* FIXME */
1598                 .cf_max    = 0, /* FIXME */
1599                 .vco_min   = 12000000,
1600                 .vco_max   = 26000000,
1601                 .freq_table = tegra_pll_s_freq_table,
1602                 .lock_delay = 300,
1603         },
1604 };
1605
1606 static struct clk_mux_sel tegra_clk_m_sel[] = {
1607         { .input = &tegra_clk_32k, .value = 0},
1608         { .input = &tegra_pll_s,  .value = 1},
1609         { 0, 0},
1610 };
1611
1612 static struct clk tegra_clk_m = {
1613         .name      = "clk_m",
1614         .flags     = ENABLE_ON_INIT,
1615         .ops       = &tegra_clk_m_ops,
1616         .inputs    = tegra_clk_m_sel,
1617         .reg       = 0x1fc,
1618         .reg_shift = 28,
1619         .max_rate  = 26000000,
1620 };
1621
1622 static struct clk_pll_freq_table tegra_pll_c_freq_table[] = {
1623         { 12000000, 522000000, 348, 8, 1, 8},
1624         { 13000000, 522000000, 522, 13, 1, 8},
1625         { 19200000, 522000000, 435, 16, 1, 8},
1626         { 26000000, 522000000, 522, 26, 1, 8},
1627         { 12000000, 598000000, 598, 12, 1, 8},
1628         { 13000000, 598000000, 598, 13, 1, 8},
1629         { 19200000, 598000000, 375, 12, 1, 6},
1630         { 26000000, 598000000, 598, 26, 1, 8},
1631         { 0, 0, 0, 0, 0, 0 },
1632 };
1633
1634 static struct clk tegra_pll_c = {
1635         .name      = "pll_c",
1636         .flags     = PLL_HAS_CPCON,
1637         .ops       = &tegra_pll_ops,
1638         .reg       = 0x80,
1639         .parent    = &tegra_clk_m,
1640         .max_rate  = 600000000,
1641         .u.pll = {
1642                 .input_min = 2000000,
1643                 .input_max = 31000000,
1644                 .cf_min    = 1000000,
1645                 .cf_max    = 6000000,
1646                 .vco_min   = 20000000,
1647                 .vco_max   = 1400000000,
1648                 .freq_table = tegra_pll_c_freq_table,
1649                 .lock_delay = 300,
1650         },
1651 };
1652
1653 static struct clk tegra_pll_c_out1 = {
1654         .name      = "pll_c_out1",
1655         .ops       = &tegra_pll_div_ops,
1656         .flags     = DIV_U71,
1657         .parent    = &tegra_pll_c,
1658         .reg       = 0x84,
1659         .reg_shift = 0,
1660         .max_rate  = 600000000,
1661 };
1662
1663 static struct clk_pll_freq_table tegra_pll_m_freq_table[] = {
1664         { 12000000, 666000000, 666, 12, 1, 8},
1665         { 13000000, 666000000, 666, 13, 1, 8},
1666         { 19200000, 666000000, 555, 16, 1, 8},
1667         { 26000000, 666000000, 666, 26, 1, 8},
1668         { 12000000, 600000000, 600, 12, 1, 8},
1669         { 13000000, 600000000, 600, 13, 1, 8},
1670         { 19200000, 600000000, 375, 12, 1, 6},
1671         { 26000000, 600000000, 600, 26, 1, 8},
1672         { 0, 0, 0, 0, 0, 0 },
1673 };
1674
1675 static struct clk tegra_pll_m = {
1676         .name      = "pll_m",
1677         .flags     = PLL_HAS_CPCON,
1678         .ops       = &tegra_pll_ops,
1679         .reg       = 0x90,
1680         .parent    = &tegra_clk_m,
1681         .max_rate  = 800000000,
1682         .u.pll = {
1683                 .input_min = 2000000,
1684                 .input_max = 31000000,
1685                 .cf_min    = 1000000,
1686                 .cf_max    = 6000000,
1687                 .vco_min   = 20000000,
1688                 .vco_max   = 1200000000,
1689                 .freq_table = tegra_pll_m_freq_table,
1690                 .lock_delay = 300,
1691         },
1692 };
1693
1694 static struct clk tegra_pll_m_out1 = {
1695         .name      = "pll_m_out1",
1696         .ops       = &tegra_pll_div_ops,
1697         .flags     = DIV_U71,
1698         .parent    = &tegra_pll_m,
1699         .reg       = 0x94,
1700         .reg_shift = 0,
1701         .max_rate  = 600000000,
1702 };
1703
1704 static struct clk_pll_freq_table tegra_pll_p_freq_table[] = {
1705         { 12000000, 216000000, 432, 12, 2, 8},
1706         { 13000000, 216000000, 432, 13, 2, 8},
1707         { 19200000, 216000000, 90,   4, 2, 1},
1708         { 26000000, 216000000, 432, 26, 2, 8},
1709         { 12000000, 432000000, 432, 12, 1, 8},
1710         { 13000000, 432000000, 432, 13, 1, 8},
1711         { 19200000, 432000000, 90,   4, 1, 1},
1712         { 26000000, 432000000, 432, 26, 1, 8},
1713         { 0, 0, 0, 0, 0, 0 },
1714 };
1715
1716 static struct clk tegra_pll_p = {
1717         .name      = "pll_p",
1718         .flags     = ENABLE_ON_INIT | PLL_FIXED | PLL_HAS_CPCON,
1719         .ops       = &tegra_pll_ops,
1720         .reg       = 0xa0,
1721         .parent    = &tegra_clk_m,
1722         .max_rate  = 432000000,
1723         .u.pll = {
1724                 .input_min = 2000000,
1725                 .input_max = 31000000,
1726                 .cf_min    = 1000000,
1727                 .cf_max    = 6000000,
1728                 .vco_min   = 20000000,
1729                 .vco_max   = 1400000000,
1730                 .freq_table = tegra_pll_p_freq_table,
1731                 .lock_delay = 300,
1732         },
1733 };
1734
1735 static struct clk tegra_pll_p_out1 = {
1736         .name      = "pll_p_out1",
1737         .ops       = &tegra_pll_div_ops,
1738         .flags     = ENABLE_ON_INIT | DIV_U71 | DIV_U71_FIXED,
1739         .parent    = &tegra_pll_p,
1740         .reg       = 0xa4,
1741         .reg_shift = 0,
1742         .max_rate  = 432000000,
1743 };
1744
1745 static struct clk tegra_pll_p_out2 = {
1746         .name      = "pll_p_out2",
1747         .ops       = &tegra_pll_div_ops,
1748         .flags     = ENABLE_ON_INIT | DIV_U71 | DIV_U71_FIXED,
1749         .parent    = &tegra_pll_p,
1750         .reg       = 0xa4,
1751         .reg_shift = 16,
1752         .max_rate  = 432000000,
1753 };
1754
1755 static struct clk tegra_pll_p_out3 = {
1756         .name      = "pll_p_out3",
1757         .ops       = &tegra_pll_div_ops,
1758         .flags     = ENABLE_ON_INIT | DIV_U71 | DIV_U71_FIXED,
1759         .parent    = &tegra_pll_p,
1760         .reg       = 0xa8,
1761         .reg_shift = 0,
1762         .max_rate  = 432000000,
1763 };
1764
1765 static struct clk tegra_pll_p_out4 = {
1766         .name      = "pll_p_out4",
1767         .ops       = &tegra_pll_div_ops,
1768         .flags     = ENABLE_ON_INIT | DIV_U71 | DIV_U71_FIXED,
1769         .parent    = &tegra_pll_p,
1770         .reg       = 0xa8,
1771         .reg_shift = 16,
1772         .max_rate  = 432000000,
1773 };
1774
1775 static struct clk_pll_freq_table tegra_pll_a_freq_table[] = {
1776         { 28800000, 56448000, 49, 25, 1, 1},
1777         { 28800000, 73728000, 64, 25, 1, 1},
1778         { 28800000, 24000000,  5,  6, 1, 1},
1779         { 0, 0, 0, 0, 0, 0 },
1780 };
1781
1782 static struct clk tegra_pll_a = {
1783         .name      = "pll_a",
1784         .flags     = PLL_HAS_CPCON,
1785         .ops       = &tegra_pll_ops,
1786         .reg       = 0xb0,
1787         .parent    = &tegra_pll_p_out1,
1788         .max_rate  = 73728000,
1789         .u.pll = {
1790                 .input_min = 2000000,
1791                 .input_max = 31000000,
1792                 .cf_min    = 1000000,
1793                 .cf_max    = 6000000,
1794                 .vco_min   = 20000000,
1795                 .vco_max   = 1400000000,
1796                 .freq_table = tegra_pll_a_freq_table,
1797                 .lock_delay = 300,
1798         },
1799 };
1800
1801 static struct clk tegra_pll_a_out0 = {
1802         .name      = "pll_a_out0",
1803         .ops       = &tegra_pll_div_ops,
1804         .flags     = DIV_U71,
1805         .parent    = &tegra_pll_a,
1806         .reg       = 0xb4,
1807         .reg_shift = 0,
1808         .max_rate  = 73728000,
1809 };
1810
1811 static struct clk_pll_freq_table tegra_pll_d_freq_table[] = {
1812         { 12000000, 216000000, 216, 12, 1, 4},
1813         { 13000000, 216000000, 216, 13, 1, 4},
1814         { 19200000, 216000000, 135, 12, 1, 3},
1815         { 26000000, 216000000, 216, 26, 1, 4},
1816
1817         { 12000000,   5000000, 10, 24, 1, 4},
1818         { 12000000,  10000000, 10, 12, 1, 4},
1819         { 12000000, 161500000, 323, 24, 1, 4},
1820         { 12000000, 162000000, 162, 12, 1, 4},
1821
1822         { 12000000, 594000000, 594, 12, 1, 8},
1823         { 13000000, 594000000, 594, 13, 1, 8},
1824         { 19200000, 594000000, 495, 16, 1, 8},
1825         { 26000000, 594000000, 594, 26, 1, 8},
1826
1827         { 12000000, 1000000000, 1000, 12, 1, 12},
1828         { 13000000, 1000000000, 1000, 13, 1, 12},
1829         { 19200000, 1000000000, 625,  12, 1, 8},
1830         { 26000000, 1000000000, 1000, 26, 1, 12},
1831
1832         { 12000000, 504000000, 504, 12, 1, 8},
1833         { 13000000, 504000000, 504, 13, 1, 8},
1834         { 19200000, 504000000, 420, 16, 1, 8},
1835         { 26000000, 504000000, 504, 26, 1, 8},
1836
1837         { 0, 0, 0, 0, 0, 0 },
1838 };
1839
1840 static struct clk tegra_pll_d = {
1841         .name      = "pll_d",
1842         .flags     = PLL_HAS_CPCON | PLLD,
1843         .ops       = &tegra_pll_ops,
1844         .reg       = 0xd0,
1845         .parent    = &tegra_clk_m,
1846         .max_rate  = 1000000000,
1847         .u.pll = {
1848                 .input_min = 2000000,
1849                 .input_max = 40000000,
1850                 .cf_min    = 1000000,
1851                 .cf_max    = 6000000,
1852                 .vco_min   = 40000000,
1853                 .vco_max   = 1000000000,
1854                 .freq_table = tegra_pll_d_freq_table,
1855                 .lock_delay = 1000,
1856         },
1857 };
1858
1859 static struct clk tegra_pll_d_out0 = {
1860         .name      = "pll_d_out0",
1861         .ops       = &tegra_pll_div_ops,
1862         .flags     = DIV_2 | PLLD,
1863         .parent    = &tegra_pll_d,
1864         .max_rate  = 500000000,
1865 };
1866
1867 static struct clk_pll_freq_table tegra_pll_u_freq_table[] = {
1868         { 12000000, 480000000, 960, 12, 2, 0},
1869         { 13000000, 480000000, 960, 13, 2, 0},
1870         { 19200000, 480000000, 200, 4,  2, 0},
1871         { 26000000, 480000000, 960, 26, 2, 0},
1872         { 0, 0, 0, 0, 0, 0 },
1873 };
1874
1875 static struct clk tegra_pll_u = {
1876         .name      = "pll_u",
1877         .flags     = PLLU,
1878         .ops       = &tegra_pll_ops,
1879         .reg       = 0xc0,
1880         .parent    = &tegra_clk_m,
1881         .max_rate  = 480000000,
1882         .u.pll = {
1883                 .input_min = 2000000,
1884                 .input_max = 40000000,
1885                 .cf_min    = 1000000,
1886                 .cf_max    = 6000000,
1887                 .vco_min   = 480000000,
1888                 .vco_max   = 960000000,
1889                 .freq_table = tegra_pll_u_freq_table,
1890                 .lock_delay = 1000,
1891         },
1892 };
1893
1894 static struct clk_pll_freq_table tegra_pll_x_freq_table[] = {
1895         /* 1.2 GHz */
1896         { 12000000, 1200000000, 600,  6,  1, 12},
1897         { 13000000, 1200000000, 923,  10, 1, 12},
1898         { 19200000, 1200000000, 750,  12, 1, 8},
1899         { 26000000, 1200000000, 600,  13, 1, 12},
1900
1901         /* 1 GHz */
1902         { 12000000, 1000000000, 1000, 12, 1, 12},
1903         { 13000000, 1000000000, 1000, 13, 1, 12},
1904         { 19200000, 1000000000, 625,  12, 1, 8},
1905         { 26000000, 1000000000, 1000, 26, 1, 12},
1906
1907         /* 912 MHz */
1908         { 12000000, 912000000,  912,  12, 1, 12},
1909         { 13000000, 912000000,  912,  13, 1, 12},
1910         { 19200000, 912000000,  760,  16, 1, 8},
1911         { 26000000, 912000000,  912,  26, 1, 12},
1912
1913         /* 816 MHz */
1914         { 12000000, 816000000,  816,  12, 1, 12},
1915         { 13000000, 816000000,  816,  13, 1, 12},
1916         { 19200000, 816000000,  680,  16, 1, 8},
1917         { 26000000, 816000000,  816,  26, 1, 12},
1918
1919         /* 760 MHz */
1920         { 12000000, 760000000,  760,  12, 1, 12},
1921         { 13000000, 760000000,  760,  13, 1, 12},
1922         { 19200000, 760000000,  950,  24, 1, 8},
1923         { 26000000, 760000000,  760,  26, 1, 12},
1924
1925         /* 750 MHz */
1926         { 12000000, 750000000,  750,  12, 1, 12},
1927         { 13000000, 750000000,  750,  13, 1, 12},
1928         { 19200000, 750000000,  625,  16, 1, 8},
1929         { 26000000, 750000000,  750,  26, 1, 12},
1930
1931         /* 608 MHz */
1932         { 12000000, 608000000,  608,  12, 1, 12},
1933         { 13000000, 608000000,  608,  13, 1, 12},
1934         { 19200000, 608000000,  380,  12, 1, 8},
1935         { 26000000, 608000000,  608,  26, 1, 12},
1936
1937         /* 456 MHz */
1938         { 12000000, 456000000,  456,  12, 1, 12},
1939         { 13000000, 456000000,  456,  13, 1, 12},
1940         { 19200000, 456000000,  380,  16, 1, 8},
1941         { 26000000, 456000000,  456,  26, 1, 12},
1942
1943         /* 312 MHz */
1944         { 12000000, 312000000,  312,  12, 1, 12},
1945         { 13000000, 312000000,  312,  13, 1, 12},
1946         { 19200000, 312000000,  260,  16, 1, 8},
1947         { 26000000, 312000000,  312,  26, 1, 12},
1948
1949         { 0, 0, 0, 0, 0, 0 },
1950 };
1951
1952 static struct clk tegra_pll_x = {
1953         .name      = "pll_x",
1954         .flags     = PLL_HAS_CPCON | PLL_ALT_MISC_REG,
1955         .ops       = &tegra_pll_ops,
1956         .reg       = 0xe0,
1957         .parent    = &tegra_clk_m,
1958         .max_rate  = 1000000000,
1959         .u.pll = {
1960                 .input_min = 2000000,
1961                 .input_max = 31000000,
1962                 .cf_min    = 1000000,
1963                 .cf_max    = 6000000,
1964                 .vco_min   = 20000000,
1965                 .vco_max   = 1200000000,
1966                 .freq_table = tegra_pll_x_freq_table,
1967                 .lock_delay = 300,
1968         },
1969 };
1970
1971 static struct clk_pll_freq_table tegra_pll_e_freq_table[] = {
1972         { 12000000, 100000000,  200,  24, 1, 0 },
1973         { 0, 0, 0, 0, 0, 0 },
1974 };
1975
1976 static struct clk tegra_pll_e = {
1977         .name      = "pll_e",
1978         .flags     = PLL_ALT_MISC_REG,
1979         .ops       = &tegra_plle_ops,
1980         .parent    = &tegra_clk_m,
1981         .reg       = 0xe8,
1982         .max_rate  = 100000000,
1983         .u.pll = {
1984                 .input_min = 12000000,
1985                 .input_max = 12000000,
1986                 .freq_table = tegra_pll_e_freq_table,
1987         },
1988 };
1989
1990 static struct clk tegra_clk_d = {
1991         .name      = "clk_d",
1992         .flags     = PERIPH_NO_RESET,
1993         .ops       = &tegra_clk_double_ops,
1994         .reg       = 0x34,
1995         .reg_shift = 12,
1996         .parent    = &tegra_clk_m,
1997         .max_rate  = 52000000,
1998         .u.periph  = {
1999                 .clk_num = 90,
2000         },
2001 };
2002
2003 /* initialized before peripheral clocks */
2004 static struct clk_mux_sel mux_audio_sync_clk[8+1];
2005 static const struct audio_sources {
2006         const char *name;
2007         int value;
2008 } mux_audio_sync_clk_sources[] = {
2009         { .name = "spdif_in", .value = 0 },
2010         { .name = "i2s1", .value = 1 },
2011         { .name = "i2s2", .value = 2 },
2012         { .name = "pll_a_out0", .value = 4 },
2013 #if 0 /* FIXME: not implemented */
2014         { .name = "ac97", .value = 3 },
2015         { .name = "ext_audio_clk2", .value = 5 },
2016         { .name = "ext_audio_clk1", .value = 6 },
2017         { .name = "ext_vimclk", .value = 7 },
2018 #endif
2019         { 0, 0 }
2020 };
2021
2022 static struct clk tegra_clk_audio = {
2023         .name      = "audio",
2024         .inputs    = mux_audio_sync_clk,
2025         .reg       = 0x38,
2026         .max_rate  = 73728000,
2027         .ops       = &tegra_audio_sync_clk_ops
2028 };
2029
2030 static struct clk tegra_clk_audio_2x = {
2031         .name      = "audio_2x",
2032         .flags     = PERIPH_NO_RESET,
2033         .max_rate  = 48000000,
2034         .ops       = &tegra_clk_double_ops,
2035         .reg       = 0x34,
2036         .reg_shift = 8,
2037         .parent    = &tegra_clk_audio,
2038         .u.periph = {
2039                 .clk_num = 89,
2040         },
2041 };
2042
2043 struct clk_lookup tegra_audio_clk_lookups[] = {
2044         { .con_id = "audio", .clk = &tegra_clk_audio },
2045         { .con_id = "audio_2x", .clk = &tegra_clk_audio_2x }
2046 };
2047
2048 /* This is called after peripheral clocks are initialized, as the
2049  * audio_sync clock depends on some of the peripheral clocks.
2050  */
2051
2052 static void init_audio_sync_clock_mux(void)
2053 {
2054         int i;
2055         struct clk_mux_sel *sel = mux_audio_sync_clk;
2056         const struct audio_sources *src = mux_audio_sync_clk_sources;
2057         struct clk_lookup *lookup;
2058
2059         for (i = 0; src->name; i++, sel++, src++) {
2060                 sel->input = tegra_get_clock_by_name(src->name);
2061                 if (!sel->input)
2062                         pr_err("%s: could not find clk %s\n", __func__,
2063                                 src->name);
2064                 sel->value = src->value;
2065         }
2066
2067         lookup = tegra_audio_clk_lookups;
2068         for (i = 0; i < ARRAY_SIZE(tegra_audio_clk_lookups); i++, lookup++) {
2069                 clk_init(lookup->clk);
2070                 clkdev_add(lookup);
2071         }
2072 }
2073
2074 static struct clk_mux_sel mux_cclk[] = {
2075         { .input = &tegra_clk_m,        .value = 0},
2076         { .input = &tegra_pll_c,        .value = 1},
2077         { .input = &tegra_clk_32k,      .value = 2},
2078         { .input = &tegra_pll_m,        .value = 3},
2079         { .input = &tegra_pll_p,        .value = 4},
2080         { .input = &tegra_pll_p_out4,   .value = 5},
2081         { .input = &tegra_pll_p_out3,   .value = 6},
2082         { .input = &tegra_clk_d,        .value = 7},
2083         { .input = &tegra_pll_x,        .value = 8},
2084         { 0, 0},
2085 };
2086
2087 static struct clk_mux_sel mux_sclk[] = {
2088         { .input = &tegra_clk_m,        .value = 0},
2089         { .input = &tegra_pll_c_out1,   .value = 1},
2090         { .input = &tegra_pll_p_out4,   .value = 2},
2091         { .input = &tegra_pll_p_out3,   .value = 3},
2092         { .input = &tegra_pll_p_out2,   .value = 4},
2093         { .input = &tegra_clk_d,        .value = 5},
2094         { .input = &tegra_clk_32k,      .value = 6},
2095         { .input = &tegra_pll_m_out1,   .value = 7},
2096         { 0, 0},
2097 };
2098
2099 static struct clk tegra_clk_cclk = {
2100         .name   = "cclk",
2101         .inputs = mux_cclk,
2102         .reg    = 0x20,
2103         .ops    = &tegra_super_ops,
2104         .max_rate = 1000000000,
2105 };
2106
2107 static struct clk tegra_clk_sclk = {
2108         .name   = "sclk",
2109         .inputs = mux_sclk,
2110         .reg    = 0x28,
2111         .ops    = &tegra_super_ops,
2112         .max_rate = 240000000,
2113         .min_rate = 40000000,
2114 };
2115
2116 static struct clk tegra_clk_virtual_cpu = {
2117         .name      = "cpu",
2118         .parent    = &tegra_clk_cclk,
2119         .ops       = &tegra_cpu_ops,
2120         .max_rate  = 1000000000,
2121         .u.cpu = {
2122                 .main      = &tegra_pll_x,
2123                 .backup    = &tegra_pll_p,
2124         },
2125 };
2126
2127 static struct clk tegra_clk_cop = {
2128         .name      = "cop",
2129         .parent    = &tegra_clk_sclk,
2130         .ops       = &tegra_cop_ops,
2131         .max_rate  = 240000000,
2132 };
2133
2134 static struct clk tegra_clk_hclk = {
2135         .name           = "hclk",
2136         .flags          = DIV_BUS,
2137         .parent         = &tegra_clk_sclk,
2138         .reg            = 0x30,
2139         .reg_shift      = 4,
2140         .ops            = &tegra_bus_ops,
2141         .max_rate       = 240000000,
2142         .min_rate       = 36000000,
2143 };
2144
2145 static struct clk tegra_clk_pclk = {
2146         .name           = "pclk",
2147         .flags          = DIV_BUS,
2148         .parent         = &tegra_clk_hclk,
2149         .reg            = 0x30,
2150         .reg_shift      = 0,
2151         .ops            = &tegra_bus_ops,
2152         .max_rate       = 120000000,
2153         .min_rate       = 36000000,
2154 };
2155
2156 static struct clk tegra_clk_virtual_sclk = {
2157         .name   = "virt_sclk",
2158         .parent = &tegra_clk_sclk,
2159         .ops    = &tegra_virtual_sclk_ops,
2160         .u.system = {
2161                 .pclk = &tegra_clk_pclk,
2162         },
2163 };
2164
2165 static struct clk tegra_clk_blink = {
2166         .name           = "blink",
2167         .parent         = &tegra_clk_32k,
2168         .reg            = 0x40,
2169         .ops            = &tegra_blink_clk_ops,
2170         .max_rate       = 32768,
2171 };
2172 static struct clk_mux_sel mux_dev1_clk[] = {
2173         { .input = &tegra_clk_m,        .value = 0 },
2174         { .input = &tegra_pll_a_out0,   .value = 1 },
2175         { .input = &tegra_pll_m_out1,   .value = 2 },
2176         { .input = &tegra_clk_audio,    .value = 3 },
2177         { 0, 0 }
2178 };
2179
2180 static struct clk_mux_sel mux_dev2_clk[] = {
2181         { .input = &tegra_clk_m,        .value = 0 },
2182         { .input = &tegra_clk_hclk,     .value = 1 },
2183         { .input = &tegra_clk_pclk,     .value = 2 },
2184         { .input = &tegra_pll_p_out4,   .value = 3 },
2185         { 0, 0 }
2186 };
2187
2188 /* dap_mclk1, belongs to the cdev1 pingroup. */
2189 static struct clk tegra_clk_cdev1 = {
2190         .name      = "cdev1",
2191         .ops       = &tegra_cdev_clk_ops,
2192         .inputs    = mux_dev1_clk,
2193         .u.periph  = {
2194                 .clk_num = 94,
2195         },
2196         .flags     = MUX,
2197 };
2198
2199 /* dap_mclk2, belongs to the cdev2 pingroup. */
2200 static struct clk tegra_clk_cdev2 = {
2201         .name      = "cdev2",
2202         .ops       = &tegra_cdev_clk_ops,
2203         .inputs    = mux_dev2_clk,
2204         .u.periph  = {
2205                 .clk_num = 93,
2206         },
2207         .flags     = MUX,
2208 };
2209
2210 static struct clk_mux_sel mux_pllm_pllc_pllp_plla[] = {
2211         { .input = &tegra_pll_m, .value = 0},
2212         { .input = &tegra_pll_c, .value = 1},
2213         { .input = &tegra_pll_p, .value = 2},
2214         { .input = &tegra_pll_a_out0, .value = 3},
2215         { 0, 0},
2216 };
2217
2218 static struct clk_mux_sel mux_pllm_pllc_pllp_clkm[] = {
2219         { .input = &tegra_pll_m, .value = 0},
2220         { .input = &tegra_pll_c, .value = 1},
2221         { .input = &tegra_pll_p, .value = 2},
2222         { .input = &tegra_clk_m, .value = 3},
2223         { 0, 0},
2224 };
2225
2226 static struct clk_mux_sel mux_pllp_pllc_pllm_clkm[] = {
2227         { .input = &tegra_pll_p, .value = 0},
2228         { .input = &tegra_pll_c, .value = 1},
2229         { .input = &tegra_pll_m, .value = 2},
2230         { .input = &tegra_clk_m, .value = 3},
2231         { 0, 0},
2232 };
2233
2234 static struct clk_mux_sel mux_pllaout0_audio2x_pllp_clkm[] = {
2235         {.input = &tegra_pll_a_out0, .value = 0},
2236         {.input = &tegra_clk_audio_2x, .value = 1},
2237         {.input = &tegra_pll_p, .value = 2},
2238         {.input = &tegra_clk_m, .value = 3},
2239         { 0, 0},
2240 };
2241
2242 static struct clk_mux_sel mux_pllp_plld_pllc_clkm[] = {
2243         {.input = &tegra_pll_p, .value = 0},
2244         {.input = &tegra_pll_d_out0, .value = 1},
2245         {.input = &tegra_pll_c, .value = 2},
2246         {.input = &tegra_clk_m, .value = 3},
2247         { 0, 0},
2248 };
2249
2250 static struct clk_mux_sel mux_pllp_pllc_audio_clkm_clk32[] = {
2251         {.input = &tegra_pll_p,     .value = 0},
2252         {.input = &tegra_pll_c,     .value = 1},
2253         {.input = &tegra_clk_audio,     .value = 2},
2254         {.input = &tegra_clk_m,     .value = 3},
2255         {.input = &tegra_clk_32k,   .value = 4},
2256         { 0, 0},
2257 };
2258
2259 static struct clk_mux_sel mux_pllp_pllc_pllm[] = {
2260         {.input = &tegra_pll_p,     .value = 0},
2261         {.input = &tegra_pll_c,     .value = 1},
2262         {.input = &tegra_pll_m,     .value = 2},
2263         { 0, 0},
2264 };
2265
2266 static struct clk_mux_sel mux_clk_m[] = {
2267         { .input = &tegra_clk_m, .value = 0},
2268         { 0, 0},
2269 };
2270
2271 static struct clk_mux_sel mux_pllp_out3[] = {
2272         { .input = &tegra_pll_p_out3, .value = 0},
2273         { 0, 0},
2274 };
2275
2276 static struct clk_mux_sel mux_plld_out0[] = {
2277         { .input = &tegra_pll_d_out0, .value = 0},
2278         { 0, 0},
2279 };
2280
2281 static struct clk_mux_sel mux_clk_32k[] = {
2282         { .input = &tegra_clk_32k, .value = 0},
2283         { 0, 0},
2284 };
2285
2286 static struct clk_mux_sel mux_pclk[] = {
2287         { .input = &tegra_clk_pclk, .value = 0},
2288         { 0, 0},
2289 };
2290
2291 static struct clk tegra_clk_emc = {
2292         .name = "emc",
2293         .ops = &tegra_emc_clk_ops,
2294         .reg = 0x19c,
2295         .max_rate = 800000000,
2296         .inputs = mux_pllm_pllc_pllp_clkm,
2297         .flags = MUX | DIV_U71 | PERIPH_EMC_ENB,
2298         .u.periph = {
2299                 .clk_num = 57,
2300         },
2301 };
2302
2303 #define PERIPH_CLK(_name, _dev, _con, _clk_num, _reg, _reg_shift, _max, _inputs, _flags) \
2304         {                                               \
2305                 .name      = _name,                     \
2306                 .lookup    = {                          \
2307                         .dev_id    = _dev,              \
2308                         .con_id    = _con,              \
2309                 },                                      \
2310                 .ops       = &tegra_periph_clk_ops,     \
2311                 .reg       = _reg,                      \
2312                 .reg_shift = _reg_shift,                \
2313                 .inputs    = _inputs,                   \
2314                 .flags     = _flags,                    \
2315                 .max_rate  = _max,                      \
2316                 .u.periph = {                           \
2317                         .clk_num   = _clk_num,          \
2318                 },                                      \
2319         }
2320
2321 #define SHARED_CLK(_name, _dev, _con, _parent)          \
2322         {                                               \
2323                 .name      = _name,                     \
2324                 .lookup    = {                          \
2325                         .dev_id    = _dev,              \
2326                         .con_id    = _con,              \
2327                 },                                      \
2328                 .ops       = &tegra_clk_shared_bus_ops, \
2329                 .parent = _parent,                      \
2330         }
2331
2332 struct clk tegra_list_periph_clks[] = {
2333         PERIPH_CLK("apbdma",    "tegra-dma",            NULL,   34,     0,      0x31E,  108000000, mux_pclk,                    0),
2334         PERIPH_CLK("rtc",       "rtc-tegra",            NULL,   4,      0,      0x31E,  32768,     mux_clk_32k,                 PERIPH_NO_RESET | PERIPH_ON_APB),
2335         PERIPH_CLK("kbc",       "tegra-kbc",            NULL,   36,     0,      0x31E,  32768,     mux_clk_32k, PERIPH_NO_RESET | PERIPH_ON_APB),
2336         PERIPH_CLK("timer",     "timer",                NULL,   5,      0,      0x31E,  26000000,  mux_clk_m,                   0),
2337         PERIPH_CLK("i2s1",      "tegra20-i2s.0",        NULL,   11,     0x100,  0x31E,  26000000,  mux_pllaout0_audio2x_pllp_clkm,      MUX | DIV_U71 | PERIPH_ON_APB),
2338         PERIPH_CLK("i2s2",      "tegra20-i2s.1",        NULL,   18,     0x104,  0x31E,  26000000,  mux_pllaout0_audio2x_pllp_clkm,      MUX | DIV_U71 | PERIPH_ON_APB),
2339         PERIPH_CLK("kfuse",     "kfuse-tegra",          NULL,   40,     0,      0x31E,  26000000,  mux_clk_m,                   0),
2340         PERIPH_CLK("spdif_out", "tegra20-spdif",        "spdif_out",    10,     0x108,  0x31E,  100000000, mux_pllaout0_audio2x_pllp_clkm,      MUX | DIV_U71 | PERIPH_ON_APB),
2341         PERIPH_CLK("spdif_in",  "tegra20-spdif",        "spdif_in",     10,     0x10c,  0x31E,  100000000, mux_pllp_pllc_pllm,          MUX | DIV_U71 | PERIPH_ON_APB),
2342         PERIPH_CLK("pwm",       "pwm",                  NULL,   17,     0x110,  0x71C,  432000000, mux_pllp_pllc_audio_clkm_clk32,      MUX | DIV_U71 | PERIPH_ON_APB),
2343         PERIPH_CLK("spi",       "spi",                  NULL,   43,     0x114,  0x31E,  40000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
2344         PERIPH_CLK("xio",       "xio",                  NULL,   45,     0x120,  0x31E,  150000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2345         PERIPH_CLK("twc",       "twc",                  NULL,   16,     0x12c,  0x31E,  150000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
2346         PERIPH_CLK("sbc1",      "spi_tegra.0",          NULL,   41,     0x134,  0x31E,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
2347         PERIPH_CLK("sbc2",      "spi_tegra.1",          NULL,   44,     0x118,  0x31E,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
2348         PERIPH_CLK("sbc3",      "spi_tegra.2",          NULL,   46,     0x11c,  0x31E,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
2349         PERIPH_CLK("sbc4",      "spi_tegra.3",          NULL,   68,     0x1b4,  0x31E,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
2350         PERIPH_CLK("ide",       "ide",                  NULL,   25,     0x144,  0x31E,  100000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* requires min voltage */
2351         PERIPH_CLK("ndflash",   "tegra_nand",           NULL,   13,     0x160,  0x31E,  164000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
2352         PERIPH_CLK("vfir",      "vfir",                 NULL,   7,      0x168,  0x31E,  72000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
2353         PERIPH_CLK("sdmmc1",    "sdhci-tegra.0",        NULL,   14,     0x150,  0x31E,  52000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
2354         PERIPH_CLK("sdmmc2",    "sdhci-tegra.1",        NULL,   9,      0x154,  0x31E,  52000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
2355         PERIPH_CLK("sdmmc3",    "sdhci-tegra.2",        NULL,   69,     0x1bc,  0x31E,  52000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
2356         PERIPH_CLK("sdmmc4",    "sdhci-tegra.3",        NULL,   15,     0x164,  0x31E,  52000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
2357         PERIPH_CLK("vcp",       "tegra-avp",            "vcp",  29,     0,      0x31E,  250000000, mux_clk_m,                   0),
2358         PERIPH_CLK("bsea",      "tegra-avp",            "bsea", 62,     0,      0x31E,  250000000, mux_clk_m,                   0),
2359         PERIPH_CLK("bsev",      "tegra-aes",            "bsev", 63,     0,      0x31E,  250000000, mux_clk_m,                   0),
2360         PERIPH_CLK("vde",       "tegra-avp",            "vde",  61,     0x1c8,  0x31E,  250000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage and process_id */
2361         PERIPH_CLK("csite",     "csite",                NULL,   73,     0x1d4,  0x31E,  144000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* max rate ??? */
2362         /* FIXME: what is la? */
2363         PERIPH_CLK("la",        "la",                   NULL,   76,     0x1f8,  0x31E,  26000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2364         PERIPH_CLK("owr",       "tegra_w1",             NULL,   71,     0x1cc,  0x31E,  26000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
2365         PERIPH_CLK("nor",       "nor",                  NULL,   42,     0x1d0,  0x31E,  92000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* requires min voltage */
2366         PERIPH_CLK("mipi",      "mipi",                 NULL,   50,     0x174,  0x31E,  60000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB), /* scales with voltage */
2367         PERIPH_CLK("i2c1",      "tegra-i2c.0",          NULL,   12,     0x124,  0x31E,  26000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U16 | PERIPH_ON_APB),
2368         PERIPH_CLK("i2c2",      "tegra-i2c.1",          NULL,   54,     0x198,  0x31E,  26000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U16 | PERIPH_ON_APB),
2369         PERIPH_CLK("i2c3",      "tegra-i2c.2",          NULL,   67,     0x1b8,  0x31E,  26000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U16 | PERIPH_ON_APB),
2370         PERIPH_CLK("dvc",       "tegra-i2c.3",          NULL,   47,     0x128,  0x31E,  26000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U16 | PERIPH_ON_APB),
2371         PERIPH_CLK("uarta",     "tegra_uart.0",         NULL,   6,      0x178,  0x31E,  600000000, mux_pllp_pllc_pllm_clkm,     MUX | PERIPH_ON_APB),
2372         PERIPH_CLK("uartb",     "tegra_uart.1",         NULL,   7,      0x17c,  0x31E,  600000000, mux_pllp_pllc_pllm_clkm,     MUX | PERIPH_ON_APB),
2373         PERIPH_CLK("uartc",     "tegra_uart.2",         NULL,   55,     0x1a0,  0x31E,  600000000, mux_pllp_pllc_pllm_clkm,     MUX | PERIPH_ON_APB),
2374         PERIPH_CLK("uartd",     "tegra_uart.3",         NULL,   65,     0x1c0,  0x31E,  600000000, mux_pllp_pllc_pllm_clkm,     MUX | PERIPH_ON_APB),
2375         PERIPH_CLK("uarte",     "tegra_uart.4",         NULL,   66,     0x1c4,  0x31E,  600000000, mux_pllp_pllc_pllm_clkm,     MUX | PERIPH_ON_APB),
2376         PERIPH_CLK("3d",        "3d",                   NULL,   24,     0x158,  0x31E,  300000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71 | PERIPH_MANUAL_RESET), /* scales with voltage and process_id */
2377         PERIPH_CLK("2d",        "2d",                   NULL,   21,     0x15c,  0x31E,  300000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71), /* scales with voltage and process_id */
2378         PERIPH_CLK("vi",        "tegra_camera",         "vi",   20,     0x148,  0x31E,  150000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71), /* scales with voltage and process_id */
2379         PERIPH_CLK("vi_sensor", "tegra_camera",         "vi_sensor",    20,     0x1a8,  0x31E,  150000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71 | PERIPH_NO_RESET), /* scales with voltage and process_id */
2380         PERIPH_CLK("epp",       "epp",                  NULL,   19,     0x16c,  0x31E,  300000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71), /* scales with voltage and process_id */
2381         PERIPH_CLK("mpe",       "mpe",                  NULL,   60,     0x170,  0x31E,  300000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71), /* scales with voltage and process_id */
2382         PERIPH_CLK("host1x",    "host1x",               NULL,   28,     0x180,  0x31E,  166000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71), /* scales with voltage and process_id */
2383         PERIPH_CLK("cve",       "cve",                  NULL,   49,     0x140,  0x31E,  250000000, mux_pllp_plld_pllc_clkm,     MUX | DIV_U71), /* requires min voltage */
2384         PERIPH_CLK("tvo",       "tvo",                  NULL,   49,     0x188,  0x31E,  250000000, mux_pllp_plld_pllc_clkm,     MUX | DIV_U71), /* requires min voltage */
2385         PERIPH_CLK("hdmi",      "hdmi",                 NULL,   51,     0x18c,  0x31E,  600000000, mux_pllp_plld_pllc_clkm,     MUX | DIV_U71), /* requires min voltage */
2386         PERIPH_CLK("tvdac",     "tvdac",                NULL,   53,     0x194,  0x31E,  250000000, mux_pllp_plld_pllc_clkm,     MUX | DIV_U71), /* requires min voltage */
2387         PERIPH_CLK("disp1",     "tegradc.0",            NULL,   27,     0x138,  0x31E,  600000000, mux_pllp_plld_pllc_clkm,     MUX), /* scales with voltage and process_id */
2388         PERIPH_CLK("disp2",     "tegradc.1",            NULL,   26,     0x13c,  0x31E,  600000000, mux_pllp_plld_pllc_clkm,     MUX), /* scales with voltage and process_id */
2389         PERIPH_CLK("usbd",      "fsl-tegra-udc",        NULL,   22,     0,      0x31E,  480000000, mux_clk_m,                   0), /* requires min voltage */
2390         PERIPH_CLK("usb2",      "tegra-ehci.1",         NULL,   58,     0,      0x31E,  480000000, mux_clk_m,                   0), /* requires min voltage */
2391         PERIPH_CLK("usb3",      "tegra-ehci.2",         NULL,   59,     0,      0x31E,  480000000, mux_clk_m,                   0), /* requires min voltage */
2392         PERIPH_CLK("dsi",       "dsi",                  NULL,   48,     0,      0x31E,  500000000, mux_plld_out0,               0), /* scales with voltage */
2393         PERIPH_CLK("csi",       "tegra_camera",         "csi",  52,     0,      0x31E,  72000000,  mux_pllp_out3,               0),
2394         PERIPH_CLK("isp",       "tegra_camera",         "isp",  23,     0,      0x31E,  150000000, mux_clk_m,                   0), /* same frequency as VI */
2395         PERIPH_CLK("csus",      "tegra_camera",         "csus", 92,     0,      0x31E,  150000000, mux_clk_m,                   PERIPH_NO_RESET),
2396         PERIPH_CLK("pex",       NULL,                   "pex",  70,     0,      0x31E,  26000000,  mux_clk_m,                   PERIPH_MANUAL_RESET),
2397         PERIPH_CLK("afi",       NULL,                   "afi",  72,     0,      0x31E,  26000000,  mux_clk_m,                   PERIPH_MANUAL_RESET),
2398         PERIPH_CLK("pcie_xclk", NULL,             "pcie_xclk",  74,     0,      0x31E,  26000000,  mux_clk_m,                   PERIPH_MANUAL_RESET),
2399         PERIPH_CLK("stat_mon",  "tegra-stat-mon",       NULL,   37,     0,      0x31E,  26000000,  mux_clk_m,                   0),
2400 };
2401
2402 struct clk tegra_list_shared_clks[] = {
2403         SHARED_CLK("avp.sclk",  "tegra-avp",            "sclk", &tegra_clk_virtual_sclk),
2404         SHARED_CLK("mon.sclk",  "tegra-stat-mon",       "sclk", &tegra_clk_virtual_sclk),
2405         SHARED_CLK("bsea.sclk", "tegra-aes",            "sclk", &tegra_clk_virtual_sclk),
2406         SHARED_CLK("usbd.sclk", "fsl-tegra-udc",        "sclk", &tegra_clk_virtual_sclk),
2407         SHARED_CLK("usb1.sclk", "tegra-ehci.0",         "sclk", &tegra_clk_virtual_sclk),
2408         SHARED_CLK("usb2.sclk", "tegra-ehci.1",         "sclk", &tegra_clk_virtual_sclk),
2409         SHARED_CLK("usb3.sclk", "tegra-ehci.2",         "sclk", &tegra_clk_virtual_sclk),
2410         SHARED_CLK("avp.emc",   "tegra-avp",            "emc",  &tegra_clk_emc),
2411         SHARED_CLK("cpu.emc",   "cpu",                  "emc",  &tegra_clk_emc),
2412         SHARED_CLK("disp1.emc", "tegradc.0",            "emc",  &tegra_clk_emc),
2413         SHARED_CLK("disp2.emc", "tegradc.1",            "emc",  &tegra_clk_emc),
2414         SHARED_CLK("hdmi.emc",  "hdmi",                 "emc",  &tegra_clk_emc),
2415         SHARED_CLK("3d.emc",    "tegra_gr3d",           "emc",  &tegra_clk_emc),
2416         SHARED_CLK("2d.emc",    "tegra_gr2d",           "emc",  &tegra_clk_emc),
2417         SHARED_CLK("mpe.emc",   "tegra_mpe",            "emc",  &tegra_clk_emc),
2418         SHARED_CLK("usbd.emc",  "fsl-tegra-udc",        "emc",  &tegra_clk_emc),
2419         SHARED_CLK("usb1.emc",  "tegra-ehci.0",         "emc",  &tegra_clk_emc),
2420         SHARED_CLK("usb2.emc",  "tegra-ehci.1",         "emc",  &tegra_clk_emc),
2421         SHARED_CLK("usb3.emc",  "tegra-ehci.2",         "emc",  &tegra_clk_emc),
2422 };
2423
2424 #define CLK_DUPLICATE(_name, _dev, _con)                \
2425         {                                               \
2426                 .name   = _name,                        \
2427                 .lookup = {                             \
2428                         .dev_id = _dev,                 \
2429                         .con_id         = _con,         \
2430                 },                                      \
2431         }
2432
2433 /* Some clocks may be used by different drivers depending on the board
2434  * configuration.  List those here to register them twice in the clock lookup
2435  * table under two names.
2436  */
2437 struct clk_duplicate tegra_clk_duplicates[] = {
2438         CLK_DUPLICATE("uarta",  "serial8250.0", "uarta"),
2439         CLK_DUPLICATE("uartb",  "serial8250.0", "uartb"),
2440         CLK_DUPLICATE("uartc",  "serial8250.0", "uartc"),
2441         CLK_DUPLICATE("uartd",  "serial8250.0", "uartd"),
2442         CLK_DUPLICATE("uarte",  "serial8250.0", "uarte"),
2443         CLK_DUPLICATE("usbd", "utmip-pad", NULL),
2444         CLK_DUPLICATE("usbd", "tegra-ehci.0", NULL),
2445         CLK_DUPLICATE("usbd", "tegra-otg", NULL),
2446         CLK_DUPLICATE("hdmi", "tegradc.0", "hdmi"),
2447         CLK_DUPLICATE("hdmi", "tegradc.1", "hdmi"),
2448         CLK_DUPLICATE("dsi", "tegradc.0", "dsi"),
2449         CLK_DUPLICATE("dsi", "tegradc.1", "dsi"),
2450         CLK_DUPLICATE("pwm", "tegra_pwm.0", NULL),
2451         CLK_DUPLICATE("pwm", "tegra_pwm.1", NULL),
2452         CLK_DUPLICATE("pwm", "tegra_pwm.2", NULL),
2453         CLK_DUPLICATE("pwm", "tegra_pwm.3", NULL),
2454         CLK_DUPLICATE("host1x", "tegra_host1x", "host1x"),
2455         CLK_DUPLICATE("2d", "tegra_gr2d", "gr2d"),
2456         CLK_DUPLICATE("3d", "tegra_gr3d", "gr3d"),
2457         CLK_DUPLICATE("epp", "tegra_gr2d", "epp"),
2458         CLK_DUPLICATE("mpe", "tegra_mpe", "mpe"),
2459         CLK_DUPLICATE("cop", "tegra-avp", "cop"),
2460         CLK_DUPLICATE("vde", "tegra-aes", "vde"),
2461         CLK_DUPLICATE("twd", "smp_twd", NULL),
2462         CLK_DUPLICATE("bsea", "tegra-aes", "bsea"),
2463 };
2464
2465 #define CLK(dev, con, ck)       \
2466         {                       \
2467                 .dev_id = dev,  \
2468                 .con_id = con,  \
2469                 .clk = ck,      \
2470         }
2471
2472 struct clk *tegra_ptr_clks[] = {
2473         &tegra_clk_32k,
2474         &tegra_pll_s,
2475         &tegra_clk_m,
2476         &tegra_pll_m,
2477         &tegra_pll_m_out1,
2478         &tegra_pll_c,
2479         &tegra_pll_c_out1,
2480         &tegra_pll_p,
2481         &tegra_pll_p_out1,
2482         &tegra_pll_p_out2,
2483         &tegra_pll_p_out3,
2484         &tegra_pll_p_out4,
2485         &tegra_pll_a,
2486         &tegra_pll_a_out0,
2487         &tegra_pll_d,
2488         &tegra_pll_d_out0,
2489         &tegra_pll_u,
2490         &tegra_pll_x,
2491         &tegra_pll_e,
2492         &tegra_clk_cclk,
2493         &tegra_clk_sclk,
2494         &tegra_clk_hclk,
2495         &tegra_clk_pclk,
2496         &tegra_clk_d,
2497         &tegra_clk_cdev1,
2498         &tegra_clk_cdev2,
2499         &tegra_clk_virtual_cpu,
2500         &tegra_clk_virtual_sclk,
2501         &tegra_clk_blink,
2502         &tegra_clk_cop,
2503         &tegra_clk_emc,
2504         &tegra2_clk_twd,
2505 };
2506
2507 /* For some clocks maximum rate limits depend on tegra2 SKU */
2508 #define RATE_LIMIT(_name, _max_rate, _skus...)  \
2509         {                                       \
2510                 .clk_name       = _name,        \
2511                 .max_rate       = _max_rate,    \
2512                 .sku_ids        = {_skus}       \
2513         }
2514
2515 static struct tegra_sku_rate_limit sku_limits[] =
2516 {
2517         RATE_LIMIT("cpu",       750000000, 0x07, 0x10),
2518         RATE_LIMIT("cclk",      750000000, 0x07, 0x10),
2519         RATE_LIMIT("pll_x",     750000000, 0x07, 0x10),
2520
2521         RATE_LIMIT("cpu",       1000000000, 0x04, 0x08, 0x0F),
2522         RATE_LIMIT("cclk",      1000000000, 0x04, 0x08, 0x0F),
2523         RATE_LIMIT("pll_x",     1000000000, 0x04, 0x08, 0x0F),
2524
2525         RATE_LIMIT("cpu",       1200000000, 0x14, 0x17, 0x18, 0x1B, 0x1C),
2526         RATE_LIMIT("cclk",      1200000000, 0x14, 0x17, 0x18, 0x1B, 0x1C),
2527         RATE_LIMIT("pll_x",     1200000000, 0x14, 0x17, 0x18, 0x1B, 0x1C),
2528
2529         RATE_LIMIT("sclk",      240000000, 0x04, 0x7, 0x08, 0x0F, 0x10),
2530         RATE_LIMIT("hclk",      240000000, 0x04, 0x7, 0x08, 0x0F, 0x10),
2531         RATE_LIMIT("vde",       240000000, 0x04, 0x7, 0x08, 0x0F, 0x10),
2532         RATE_LIMIT("3d",        300000000, 0x04, 0x7, 0x08, 0x0F, 0x10),
2533
2534         RATE_LIMIT("host1x",    108000000, 0x0F),
2535
2536         RATE_LIMIT("sclk",      300000000, 0x14, 0x17, 0x18, 0x1B, 0x1C),
2537         RATE_LIMIT("virt_sclk", 300000000, 0x14, 0x17, 0x18, 0x1B, 0x1C),
2538         RATE_LIMIT("hclk",      300000000, 0x14, 0x17, 0x18, 0x1B, 0x1C),
2539         RATE_LIMIT("pclk",      150000000, 0x14, 0x17, 0x18, 0x1B, 0x1C),
2540         RATE_LIMIT("vde",       300000000, 0x14, 0x17, 0x18, 0x1B, 0x1C),
2541         RATE_LIMIT("3d",        400000000, 0x14, 0x17, 0x18, 0x1B, 0x1C),
2542 };
2543
2544 static void tegra2_init_sku_limits(void)
2545 {
2546         int i, j;
2547         struct clk *c;
2548         int sku_id = tegra_sku_id();
2549
2550         for (i = 0; i < ARRAY_SIZE(sku_limits); i++) {
2551                 struct tegra_sku_rate_limit *limit = &sku_limits[i];
2552
2553                 for (j = 0; (j < MAX_SAME_LIMIT_SKU_IDS) &&
2554                       (limit->sku_ids[j] != 0); j++) {
2555                         if (limit->sku_ids[j] == sku_id) {
2556                                 c = tegra_get_clock_by_name(limit->clk_name);
2557                                 if (!c) {
2558                                         pr_err("%s: Unknown sku clock %s\n",
2559                                                __func__, limit->clk_name);
2560                                         continue;
2561                                 }
2562                                 c->max_rate = limit->max_rate;
2563                         }
2564                 }
2565         }
2566 }
2567
2568 static void tegra2_init_one_clock(struct clk *c)
2569 {
2570         clk_init(c);
2571         INIT_LIST_HEAD(&c->shared_bus_list);
2572         if (!c->lookup.dev_id && !c->lookup.con_id)
2573                 c->lookup.con_id = c->name;
2574         c->lookup.clk = c;
2575         clkdev_add(&c->lookup);
2576 }
2577
2578 #ifdef CONFIG_CPU_FREQ
2579
2580 /*
2581  * Frequency table index must be sequential starting at 0 and frequencies
2582  * must be ascending.
2583  */
2584
2585 static struct cpufreq_frequency_table freq_table_750MHz[] = {
2586         { 0, 216000 },
2587         { 1, 312000 },
2588         { 2, 456000 },
2589         { 3, 608000 },
2590         { 4, 750000 },
2591         { 5, CPUFREQ_TABLE_END },
2592 };
2593
2594 static struct cpufreq_frequency_table freq_table_1p0GHz[] = {
2595         { 0, 216000 },
2596         { 1, 312000 },
2597         { 2, 456000 },
2598         { 3, 608000 },
2599         { 4, 760000 },
2600         { 5, 816000 },
2601         { 6, 912000 },
2602         { 7, 1000000 },
2603         { 8, CPUFREQ_TABLE_END },
2604 };
2605
2606 static struct cpufreq_frequency_table freq_table_1p2GHz[] = {
2607         { 0, 216000 },
2608         { 1, 312000 },
2609         { 2, 456000 },
2610         { 3, 608000 },
2611         { 4, 760000 },
2612         { 5, 816000 },
2613         { 6, 912000 },
2614         { 7, 1000000 },
2615         { 8, 1200000 },
2616         { 9, CPUFREQ_TABLE_END },
2617 };
2618
2619 static struct tegra_cpufreq_table_data cpufreq_tables[] = {
2620         { freq_table_750MHz, 1, 4 },
2621         { freq_table_1p0GHz, 2, 6 },
2622         { freq_table_1p2GHz, 2, 7 },
2623 };
2624
2625 struct tegra_cpufreq_table_data *tegra_cpufreq_table_get(void)
2626 {
2627         int i, ret;
2628         struct clk *cpu_clk = tegra_get_clock_by_name("cpu");
2629
2630         for (i = 0; i < ARRAY_SIZE(cpufreq_tables); i++) {
2631                 struct cpufreq_policy policy;
2632                 ret = cpufreq_frequency_table_cpuinfo(
2633                         &policy, cpufreq_tables[i].freq_table);
2634                 BUG_ON(ret);
2635                 if ((policy.max * 1000) == cpu_clk->max_rate)
2636                         return &cpufreq_tables[i];
2637         }
2638         pr_err("%s: No cpufreq table matching cpu range", __func__);
2639         BUG();
2640         return &cpufreq_tables[0];
2641 }
2642
2643 unsigned long tegra_emc_to_cpu_ratio(unsigned long cpu_rate)
2644 {
2645         /* Vote on memory bus frequency based on cpu frequency */
2646         if (cpu_rate >= 816000)
2647                 return 600000000;       /* cpu 816 MHz, emc max */
2648         else if (cpu_rate >= 608000)
2649                 return 300000000;       /* cpu 608 MHz, emc 150Mhz */
2650         else if (cpu_rate >= 456000)
2651                 return 150000000;       /* cpu 456 MHz, emc 75Mhz */
2652         else if (cpu_rate >= 312000)
2653                 return 100000000;       /* cpu 312 MHz, emc 50Mhz */
2654         else
2655                 return 50000000;        /* emc 25Mhz */
2656 }
2657 #endif
2658
2659 #ifdef CONFIG_PM_SLEEP
2660 static u32 clk_rst_suspend[RST_DEVICES_NUM + CLK_OUT_ENB_NUM +
2661                            PERIPH_CLK_SOURCE_NUM + 22];
2662
2663 static int tegra_clk_suspend(void)
2664 {
2665         unsigned long off, i;
2666         u32 *ctx = clk_rst_suspend;
2667
2668         *ctx++ = clk_readl(OSC_CTRL) & OSC_CTRL_MASK;
2669         *ctx++ = clk_readl(tegra_pll_c.reg + PLL_BASE);
2670         *ctx++ = clk_readl(tegra_pll_c.reg + PLL_MISC(&tegra_pll_c));
2671         *ctx++ = clk_readl(tegra_pll_a.reg + PLL_BASE);
2672         *ctx++ = clk_readl(tegra_pll_a.reg + PLL_MISC(&tegra_pll_a));
2673         *ctx++ = clk_readl(tegra_pll_s.reg + PLL_BASE);
2674         *ctx++ = clk_readl(tegra_pll_s.reg + PLL_MISC(&tegra_pll_s));
2675         *ctx++ = clk_readl(tegra_pll_d.reg + PLL_BASE);
2676         *ctx++ = clk_readl(tegra_pll_d.reg + PLL_MISC(&tegra_pll_d));
2677         *ctx++ = clk_readl(tegra_pll_u.reg + PLL_BASE);
2678         *ctx++ = clk_readl(tegra_pll_u.reg + PLL_MISC(&tegra_pll_u));
2679
2680         *ctx++ = clk_readl(tegra_pll_m_out1.reg);
2681         *ctx++ = clk_readl(tegra_pll_a_out0.reg);
2682         *ctx++ = clk_readl(tegra_pll_c_out1.reg);
2683
2684         *ctx++ = clk_readl(tegra_clk_cclk.reg);
2685         *ctx++ = clk_readl(tegra_clk_cclk.reg + SUPER_CLK_DIVIDER);
2686
2687         *ctx++ = clk_readl(tegra_clk_sclk.reg);
2688         *ctx++ = clk_readl(tegra_clk_sclk.reg + SUPER_CLK_DIVIDER);
2689         *ctx++ = clk_readl(tegra_clk_pclk.reg);
2690
2691         *ctx++ = clk_readl(tegra_clk_audio.reg);
2692
2693         for (off = PERIPH_CLK_SOURCE_I2S1; off <= PERIPH_CLK_SOURCE_OSC;
2694                         off += 4) {
2695                 if (off == PERIPH_CLK_SOURCE_EMC)
2696                         continue;
2697                 *ctx++ = clk_readl(off);
2698         }
2699
2700         off = RST_DEVICES;
2701         for (i = 0; i < RST_DEVICES_NUM; i++, off += 4)
2702                 *ctx++ = clk_readl(off);
2703
2704         off = CLK_OUT_ENB;
2705         for (i = 0; i < CLK_OUT_ENB_NUM; i++, off += 4)
2706                 *ctx++ = clk_readl(off);
2707
2708         *ctx++ = clk_readl(MISC_CLK_ENB);
2709         *ctx++ = clk_readl(CLK_MASK_ARM);
2710
2711         BUG_ON(ctx - clk_rst_suspend != ARRAY_SIZE(clk_rst_suspend));
2712
2713         return 0;
2714 }
2715
2716 static void tegra_clk_resume(void)
2717 {
2718         unsigned long off, i;
2719         const u32 *ctx = clk_rst_suspend;
2720         u32 val;
2721
2722         val = clk_readl(OSC_CTRL) & ~OSC_CTRL_MASK;
2723         val |= *ctx++;
2724         clk_writel(val, OSC_CTRL);
2725
2726         clk_writel(*ctx++, tegra_pll_c.reg + PLL_BASE);
2727         clk_writel(*ctx++, tegra_pll_c.reg + PLL_MISC(&tegra_pll_c));
2728         clk_writel(*ctx++, tegra_pll_a.reg + PLL_BASE);
2729         clk_writel(*ctx++, tegra_pll_a.reg + PLL_MISC(&tegra_pll_a));
2730         clk_writel(*ctx++, tegra_pll_s.reg + PLL_BASE);
2731         clk_writel(*ctx++, tegra_pll_s.reg + PLL_MISC(&tegra_pll_s));
2732         clk_writel(*ctx++, tegra_pll_d.reg + PLL_BASE);
2733         clk_writel(*ctx++, tegra_pll_d.reg + PLL_MISC(&tegra_pll_d));
2734         clk_writel(*ctx++, tegra_pll_u.reg + PLL_BASE);
2735         clk_writel(*ctx++, tegra_pll_u.reg + PLL_MISC(&tegra_pll_u));
2736         udelay(1000);
2737
2738         clk_writel(*ctx++, tegra_pll_m_out1.reg);
2739         clk_writel(*ctx++, tegra_pll_a_out0.reg);
2740         clk_writel(*ctx++, tegra_pll_c_out1.reg);
2741
2742         clk_writel(*ctx++, tegra_clk_cclk.reg);
2743         clk_writel(*ctx++, tegra_clk_cclk.reg + SUPER_CLK_DIVIDER);
2744
2745         clk_writel(*ctx++, tegra_clk_sclk.reg);
2746         clk_writel(*ctx++, tegra_clk_sclk.reg + SUPER_CLK_DIVIDER);
2747         clk_writel(*ctx++, tegra_clk_pclk.reg);
2748
2749         clk_writel(*ctx++, tegra_clk_audio.reg);
2750
2751         /* enable all clocks before configuring clock sources */
2752         clk_writel(0xbffffff9ul, CLK_OUT_ENB);
2753         clk_writel(0xfefffff7ul, CLK_OUT_ENB + 4);
2754         clk_writel(0x77f01bfful, CLK_OUT_ENB + 8);
2755         wmb();
2756
2757         for (off = PERIPH_CLK_SOURCE_I2S1; off <= PERIPH_CLK_SOURCE_OSC;
2758                         off += 4) {
2759                 if (off == PERIPH_CLK_SOURCE_EMC)
2760                         continue;
2761                 clk_writel(*ctx++, off);
2762         }
2763         wmb();
2764
2765         off = RST_DEVICES;
2766         for (i = 0; i < RST_DEVICES_NUM; i++, off += 4)
2767                 clk_writel(*ctx++, off);
2768         wmb();
2769
2770         off = CLK_OUT_ENB;
2771         for (i = 0; i < CLK_OUT_ENB_NUM; i++, off += 4)
2772                 clk_writel(*ctx++, off);
2773         wmb();
2774
2775         clk_writel(*ctx++, MISC_CLK_ENB);
2776         clk_writel(*ctx++, CLK_MASK_ARM);
2777 }
2778
2779 #else
2780 #define tegra_clk_suspend NULL
2781 #define tegra_clk_resume NULL
2782 #endif
2783
2784 static struct syscore_ops tegra_clk_syscore_ops = {
2785         .suspend = tegra_clk_suspend,
2786         .resume = tegra_clk_resume,
2787 };
2788
2789 void __init tegra_soc_init_clocks(void)
2790 {
2791         int i;
2792         struct clk *c;
2793
2794         for (i = 0; i < ARRAY_SIZE(tegra_ptr_clks); i++)
2795                 tegra2_init_one_clock(tegra_ptr_clks[i]);
2796
2797         for (i = 0; i < ARRAY_SIZE(tegra_list_periph_clks); i++)
2798                 tegra2_init_one_clock(&tegra_list_periph_clks[i]);
2799
2800         for (i = 0; i < ARRAY_SIZE(tegra_clk_duplicates); i++) {
2801                 c = tegra_get_clock_by_name(tegra_clk_duplicates[i].name);
2802                 if (!c) {
2803                         pr_err("%s: Unknown duplicate clock %s\n", __func__,
2804                                 tegra_clk_duplicates[i].name);
2805                         continue;
2806                 }
2807
2808                 tegra_clk_duplicates[i].lookup.clk = c;
2809                 clkdev_add(&tegra_clk_duplicates[i].lookup);
2810         }
2811
2812         init_audio_sync_clock_mux();
2813         tegra2_init_sku_limits();
2814
2815         for (i = 0; i < ARRAY_SIZE(tegra_list_shared_clks); i++)
2816                 tegra2_init_one_clock(&tegra_list_shared_clks[i]);
2817
2818         register_syscore_ops(&tegra_clk_syscore_ops);
2819 }