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