Merge tag 'cleanup2' of git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc
[linux-3.10.git] / arch / arm / mach-tegra / tegra20_clocks.c
1 /*
2  * arch/arm/mach-tegra/tegra20_clocks.c
3  *
4  * Copyright (C) 2010 Google, Inc.
5  * Copyright (c) 2010-2012 NVIDIA CORPORATION.  All rights reserved.
6  *
7  * Author:
8  *      Colin Cross <ccross@google.com>
9  *
10  * This software is licensed under the terms of the GNU General Public
11  * License version 2, as published by the Free Software Foundation, and
12  * may be copied, distributed, and modified under those terms.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  */
20
21 #include <linux/kernel.h>
22 #include <linux/module.h>
23 #include <linux/list.h>
24 #include <linux/spinlock.h>
25 #include <linux/delay.h>
26 #include <linux/io.h>
27 #include <linux/clkdev.h>
28 #include <linux/clk.h>
29
30 #include <mach/iomap.h>
31
32 #include "clock.h"
33 #include "fuse.h"
34 #include "tegra2_emc.h"
35 #include "tegra_cpu_car.h"
36
37 #define RST_DEVICES                     0x004
38 #define RST_DEVICES_SET                 0x300
39 #define RST_DEVICES_CLR                 0x304
40 #define RST_DEVICES_NUM                 3
41
42 #define CLK_OUT_ENB                     0x010
43 #define CLK_OUT_ENB_SET                 0x320
44 #define CLK_OUT_ENB_CLR                 0x324
45 #define CLK_OUT_ENB_NUM                 3
46
47 #define CLK_MASK_ARM                    0x44
48 #define MISC_CLK_ENB                    0x48
49
50 #define OSC_CTRL                        0x50
51 #define OSC_CTRL_OSC_FREQ_MASK          (3<<30)
52 #define OSC_CTRL_OSC_FREQ_13MHZ         (0<<30)
53 #define OSC_CTRL_OSC_FREQ_19_2MHZ       (1<<30)
54 #define OSC_CTRL_OSC_FREQ_12MHZ         (2<<30)
55 #define OSC_CTRL_OSC_FREQ_26MHZ         (3<<30)
56 #define OSC_CTRL_MASK                   (0x3f2 | OSC_CTRL_OSC_FREQ_MASK)
57
58 #define OSC_FREQ_DET                    0x58
59 #define OSC_FREQ_DET_TRIG               (1<<31)
60
61 #define OSC_FREQ_DET_STATUS             0x5C
62 #define OSC_FREQ_DET_BUSY               (1<<31)
63 #define OSC_FREQ_DET_CNT_MASK           0xFFFF
64
65 #define PERIPH_CLK_SOURCE_I2S1          0x100
66 #define PERIPH_CLK_SOURCE_EMC           0x19c
67 #define PERIPH_CLK_SOURCE_OSC           0x1fc
68 #define PERIPH_CLK_SOURCE_NUM \
69         ((PERIPH_CLK_SOURCE_OSC - PERIPH_CLK_SOURCE_I2S1) / 4)
70
71 #define PERIPH_CLK_SOURCE_MASK          (3<<30)
72 #define PERIPH_CLK_SOURCE_SHIFT         30
73 #define PERIPH_CLK_SOURCE_PWM_MASK      (7<<28)
74 #define PERIPH_CLK_SOURCE_PWM_SHIFT     28
75 #define PERIPH_CLK_SOURCE_ENABLE        (1<<28)
76 #define PERIPH_CLK_SOURCE_DIVU71_MASK   0xFF
77 #define PERIPH_CLK_SOURCE_DIVU16_MASK   0xFFFF
78 #define PERIPH_CLK_SOURCE_DIV_SHIFT     0
79
80 #define SDMMC_CLK_INT_FB_SEL            (1 << 23)
81 #define SDMMC_CLK_INT_FB_DLY_SHIFT      16
82 #define SDMMC_CLK_INT_FB_DLY_MASK       (0xF << SDMMC_CLK_INT_FB_DLY_SHIFT)
83
84 #define PLL_BASE                        0x0
85 #define PLL_BASE_BYPASS                 (1<<31)
86 #define PLL_BASE_ENABLE                 (1<<30)
87 #define PLL_BASE_REF_ENABLE             (1<<29)
88 #define PLL_BASE_OVERRIDE               (1<<28)
89 #define PLL_BASE_DIVP_MASK              (0x7<<20)
90 #define PLL_BASE_DIVP_SHIFT             20
91 #define PLL_BASE_DIVN_MASK              (0x3FF<<8)
92 #define PLL_BASE_DIVN_SHIFT             8
93 #define PLL_BASE_DIVM_MASK              (0x1F)
94 #define PLL_BASE_DIVM_SHIFT             0
95
96 #define PLL_OUT_RATIO_MASK              (0xFF<<8)
97 #define PLL_OUT_RATIO_SHIFT             8
98 #define PLL_OUT_OVERRIDE                (1<<2)
99 #define PLL_OUT_CLKEN                   (1<<1)
100 #define PLL_OUT_RESET_DISABLE           (1<<0)
101
102 #define PLL_MISC(c) (((c)->flags & PLL_ALT_MISC_REG) ? 0x4 : 0xc)
103
104 #define PLL_MISC_DCCON_SHIFT            20
105 #define PLL_MISC_CPCON_SHIFT            8
106 #define PLL_MISC_CPCON_MASK             (0xF<<PLL_MISC_CPCON_SHIFT)
107 #define PLL_MISC_LFCON_SHIFT            4
108 #define PLL_MISC_LFCON_MASK             (0xF<<PLL_MISC_LFCON_SHIFT)
109 #define PLL_MISC_VCOCON_SHIFT           0
110 #define PLL_MISC_VCOCON_MASK            (0xF<<PLL_MISC_VCOCON_SHIFT)
111
112 #define PLLU_BASE_POST_DIV              (1<<20)
113
114 #define PLLD_MISC_CLKENABLE             (1<<30)
115 #define PLLD_MISC_DIV_RST               (1<<23)
116 #define PLLD_MISC_DCCON_SHIFT           12
117
118 #define PLLE_MISC_READY                 (1 << 15)
119
120 #define PERIPH_CLK_TO_ENB_REG(c)        ((c->u.periph.clk_num / 32) * 4)
121 #define PERIPH_CLK_TO_ENB_SET_REG(c)    ((c->u.periph.clk_num / 32) * 8)
122 #define PERIPH_CLK_TO_ENB_BIT(c)        (1 << (c->u.periph.clk_num % 32))
123
124 #define SUPER_CLK_MUX                   0x00
125 #define SUPER_STATE_SHIFT               28
126 #define SUPER_STATE_MASK                (0xF << SUPER_STATE_SHIFT)
127 #define SUPER_STATE_STANDBY             (0x0 << SUPER_STATE_SHIFT)
128 #define SUPER_STATE_IDLE                (0x1 << SUPER_STATE_SHIFT)
129 #define SUPER_STATE_RUN                 (0x2 << SUPER_STATE_SHIFT)
130 #define SUPER_STATE_IRQ                 (0x3 << SUPER_STATE_SHIFT)
131 #define SUPER_STATE_FIQ                 (0x4 << SUPER_STATE_SHIFT)
132 #define SUPER_SOURCE_MASK               0xF
133 #define SUPER_FIQ_SOURCE_SHIFT          12
134 #define SUPER_IRQ_SOURCE_SHIFT          8
135 #define SUPER_RUN_SOURCE_SHIFT          4
136 #define SUPER_IDLE_SOURCE_SHIFT         0
137
138 #define SUPER_CLK_DIVIDER               0x04
139
140 #define BUS_CLK_DISABLE                 (1<<3)
141 #define BUS_CLK_DIV_MASK                0x3
142
143 #define PMC_CTRL                        0x0
144  #define PMC_CTRL_BLINK_ENB             (1 << 7)
145
146 #define PMC_DPD_PADS_ORIDE              0x1c
147  #define PMC_DPD_PADS_ORIDE_BLINK_ENB   (1 << 20)
148
149 #define PMC_BLINK_TIMER_DATA_ON_SHIFT   0
150 #define PMC_BLINK_TIMER_DATA_ON_MASK    0x7fff
151 #define PMC_BLINK_TIMER_ENB             (1 << 15)
152 #define PMC_BLINK_TIMER_DATA_OFF_SHIFT  16
153 #define PMC_BLINK_TIMER_DATA_OFF_MASK   0xffff
154
155 /* Tegra CPU clock and reset control regs */
156 #define TEGRA_CLK_RST_CONTROLLER_CLK_CPU_CMPLX          0x4c
157 #define TEGRA_CLK_RST_CONTROLLER_RST_CPU_CMPLX_SET      0x340
158 #define TEGRA_CLK_RST_CONTROLLER_RST_CPU_CMPLX_CLR      0x344
159
160 #define CPU_CLOCK(cpu)  (0x1 << (8 + cpu))
161 #define CPU_RESET(cpu)  (0x1111ul << (cpu))
162
163 static void __iomem *reg_clk_base = IO_ADDRESS(TEGRA_CLK_RESET_BASE);
164 static void __iomem *reg_pmc_base = IO_ADDRESS(TEGRA_PMC_BASE);
165
166 /*
167  * Some clocks share a register with other clocks.  Any clock op that
168  * non-atomically modifies a register used by another clock must lock
169  * clock_register_lock first.
170  */
171 static DEFINE_SPINLOCK(clock_register_lock);
172
173 /*
174  * Some peripheral clocks share an enable bit, so refcount the enable bits
175  * in registers CLK_ENABLE_L, CLK_ENABLE_H, and CLK_ENABLE_U
176  */
177 static int tegra_periph_clk_enable_refcount[3 * 32];
178
179 #define clk_writel(value, reg) \
180         __raw_writel(value, reg_clk_base + (reg))
181 #define clk_readl(reg) \
182         __raw_readl(reg_clk_base + (reg))
183 #define pmc_writel(value, reg) \
184         __raw_writel(value, reg_pmc_base + (reg))
185 #define pmc_readl(reg) \
186         __raw_readl(reg_pmc_base + (reg))
187
188 static unsigned long clk_measure_input_freq(void)
189 {
190         u32 clock_autodetect;
191         clk_writel(OSC_FREQ_DET_TRIG | 1, OSC_FREQ_DET);
192         do {} while (clk_readl(OSC_FREQ_DET_STATUS) & OSC_FREQ_DET_BUSY);
193         clock_autodetect = clk_readl(OSC_FREQ_DET_STATUS);
194         if (clock_autodetect >= 732 - 3 && clock_autodetect <= 732 + 3) {
195                 return 12000000;
196         } else if (clock_autodetect >= 794 - 3 && clock_autodetect <= 794 + 3) {
197                 return 13000000;
198         } else if (clock_autodetect >= 1172 - 3 && clock_autodetect <= 1172 + 3) {
199                 return 19200000;
200         } else if (clock_autodetect >= 1587 - 3 && clock_autodetect <= 1587 + 3) {
201                 return 26000000;
202         } else {
203                 pr_err("%s: Unexpected clock autodetect value %d",
204                                                 __func__, clock_autodetect);
205                 BUG();
206                 return 0;
207         }
208 }
209
210 static int clk_div71_get_divider(unsigned long parent_rate, unsigned long rate)
211 {
212         s64 divider_u71 = parent_rate * 2;
213         divider_u71 += rate - 1;
214         do_div(divider_u71, rate);
215
216         if (divider_u71 - 2 < 0)
217                 return 0;
218
219         if (divider_u71 - 2 > 255)
220                 return -EINVAL;
221
222         return divider_u71 - 2;
223 }
224
225 static int clk_div16_get_divider(unsigned long parent_rate, unsigned long rate)
226 {
227         s64 divider_u16;
228
229         divider_u16 = parent_rate;
230         divider_u16 += rate - 1;
231         do_div(divider_u16, rate);
232
233         if (divider_u16 - 1 < 0)
234                 return 0;
235
236         if (divider_u16 - 1 > 0xFFFF)
237                 return -EINVAL;
238
239         return divider_u16 - 1;
240 }
241
242 static unsigned long tegra_clk_fixed_recalc_rate(struct clk_hw *hw,
243                 unsigned long parent_rate)
244 {
245         return to_clk_tegra(hw)->fixed_rate;
246 }
247
248 struct clk_ops tegra_clk_32k_ops = {
249         .recalc_rate = tegra_clk_fixed_recalc_rate,
250 };
251
252 /* clk_m functions */
253 static unsigned long tegra20_clk_m_recalc_rate(struct clk_hw *hw,
254                         unsigned long prate)
255 {
256         if (!to_clk_tegra(hw)->fixed_rate)
257                 to_clk_tegra(hw)->fixed_rate = clk_measure_input_freq();
258         return to_clk_tegra(hw)->fixed_rate;
259 }
260
261 static void tegra20_clk_m_init(struct clk_hw *hw)
262 {
263         struct clk_tegra *c = to_clk_tegra(hw);
264         u32 osc_ctrl = clk_readl(OSC_CTRL);
265         u32 auto_clock_control = osc_ctrl & ~OSC_CTRL_OSC_FREQ_MASK;
266
267         switch (c->fixed_rate) {
268         case 12000000:
269                 auto_clock_control |= OSC_CTRL_OSC_FREQ_12MHZ;
270                 break;
271         case 13000000:
272                 auto_clock_control |= OSC_CTRL_OSC_FREQ_13MHZ;
273                 break;
274         case 19200000:
275                 auto_clock_control |= OSC_CTRL_OSC_FREQ_19_2MHZ;
276                 break;
277         case 26000000:
278                 auto_clock_control |= OSC_CTRL_OSC_FREQ_26MHZ;
279                 break;
280         default:
281                 BUG();
282         }
283         clk_writel(auto_clock_control, OSC_CTRL);
284 }
285
286 struct clk_ops tegra_clk_m_ops = {
287         .init = tegra20_clk_m_init,
288         .recalc_rate = tegra20_clk_m_recalc_rate,
289 };
290
291 /* super clock functions */
292 /* "super clocks" on tegra have two-stage muxes and a clock skipping
293  * super divider.  We will ignore the clock skipping divider, since we
294  * can't lower the voltage when using the clock skip, but we can if we
295  * lower the PLL frequency.
296  */
297 static int tegra20_super_clk_is_enabled(struct clk_hw *hw)
298 {
299         struct clk_tegra *c = to_clk_tegra(hw);
300         u32 val;
301
302         val = clk_readl(c->reg + SUPER_CLK_MUX);
303         BUG_ON(((val & SUPER_STATE_MASK) != SUPER_STATE_RUN) &&
304                 ((val & SUPER_STATE_MASK) != SUPER_STATE_IDLE));
305         c->state = ON;
306         return c->state;
307 }
308
309 static int tegra20_super_clk_enable(struct clk_hw *hw)
310 {
311         struct clk_tegra *c = to_clk_tegra(hw);
312         clk_writel(0, c->reg + SUPER_CLK_DIVIDER);
313         return 0;
314 }
315
316 static void tegra20_super_clk_disable(struct clk_hw *hw)
317 {
318         pr_debug("%s on clock %s\n", __func__, __clk_get_name(hw->clk));
319
320         /* oops - don't disable the CPU clock! */
321         BUG();
322 }
323
324 static u8 tegra20_super_clk_get_parent(struct clk_hw *hw)
325 {
326         struct clk_tegra *c = to_clk_tegra(hw);
327         int val = clk_readl(c->reg + SUPER_CLK_MUX);
328         int source;
329         int shift;
330
331         BUG_ON(((val & SUPER_STATE_MASK) != SUPER_STATE_RUN) &&
332                 ((val & SUPER_STATE_MASK) != SUPER_STATE_IDLE));
333         shift = ((val & SUPER_STATE_MASK) == SUPER_STATE_IDLE) ?
334                 SUPER_IDLE_SOURCE_SHIFT : SUPER_RUN_SOURCE_SHIFT;
335         source = (val >> shift) & SUPER_SOURCE_MASK;
336         return source;
337 }
338
339 static int tegra20_super_clk_set_parent(struct clk_hw *hw, u8 index)
340 {
341         struct clk_tegra *c = to_clk_tegra(hw);
342         u32 val = clk_readl(c->reg + SUPER_CLK_MUX);
343         int shift;
344
345         BUG_ON(((val & SUPER_STATE_MASK) != SUPER_STATE_RUN) &&
346                 ((val & SUPER_STATE_MASK) != SUPER_STATE_IDLE));
347         shift = ((val & SUPER_STATE_MASK) == SUPER_STATE_IDLE) ?
348                 SUPER_IDLE_SOURCE_SHIFT : SUPER_RUN_SOURCE_SHIFT;
349         val &= ~(SUPER_SOURCE_MASK << shift);
350         val |= index << shift;
351
352         clk_writel(val, c->reg);
353
354         return 0;
355 }
356
357 /* FIX ME: Need to switch parents to change the source PLL rate */
358 static unsigned long tegra20_super_clk_recalc_rate(struct clk_hw *hw,
359                         unsigned long prate)
360 {
361         return prate;
362 }
363
364 static long tegra20_super_clk_round_rate(struct clk_hw *hw, unsigned long rate,
365                                 unsigned long *prate)
366 {
367         return *prate;
368 }
369
370 static int tegra20_super_clk_set_rate(struct clk_hw *hw, unsigned long rate,
371                 unsigned long parent_rate)
372 {
373         return 0;
374 }
375
376 struct clk_ops tegra_super_ops = {
377         .is_enabled = tegra20_super_clk_is_enabled,
378         .enable = tegra20_super_clk_enable,
379         .disable = tegra20_super_clk_disable,
380         .set_parent = tegra20_super_clk_set_parent,
381         .get_parent = tegra20_super_clk_get_parent,
382         .set_rate = tegra20_super_clk_set_rate,
383         .round_rate = tegra20_super_clk_round_rate,
384         .recalc_rate = tegra20_super_clk_recalc_rate,
385 };
386
387 static unsigned long tegra20_twd_clk_recalc_rate(struct clk_hw *hw,
388                 unsigned long parent_rate)
389 {
390         struct clk_tegra *c = to_clk_tegra(hw);
391         u64 rate = parent_rate;
392
393         if (c->mul != 0 && c->div != 0) {
394                 rate *= c->mul;
395                 rate += c->div - 1; /* round up */
396                 do_div(rate, c->div);
397         }
398
399         return rate;
400 }
401
402 struct clk_ops tegra_twd_ops = {
403         .recalc_rate = tegra20_twd_clk_recalc_rate,
404 };
405
406 static u8 tegra20_cop_clk_get_parent(struct clk_hw *hw)
407 {
408         return 0;
409 }
410
411 struct clk_ops tegra_cop_ops = {
412         .get_parent = tegra20_cop_clk_get_parent,
413 };
414
415 /* virtual cop clock functions. Used to acquire the fake 'cop' clock to
416  * reset the COP block (i.e. AVP) */
417 void tegra2_cop_clk_reset(struct clk_hw *hw, bool assert)
418 {
419         unsigned long reg = assert ? RST_DEVICES_SET : RST_DEVICES_CLR;
420
421         pr_debug("%s %s\n", __func__, assert ? "assert" : "deassert");
422         clk_writel(1 << 1, reg);
423 }
424
425 /* bus clock functions */
426 static int tegra20_bus_clk_is_enabled(struct clk_hw *hw)
427 {
428         struct clk_tegra *c = to_clk_tegra(hw);
429         u32 val = clk_readl(c->reg);
430
431         c->state = ((val >> c->reg_shift) & BUS_CLK_DISABLE) ? OFF : ON;
432         return c->state;
433 }
434
435 static int tegra20_bus_clk_enable(struct clk_hw *hw)
436 {
437         struct clk_tegra *c = to_clk_tegra(hw);
438         unsigned long flags;
439         u32 val;
440
441         spin_lock_irqsave(&clock_register_lock, flags);
442
443         val = clk_readl(c->reg);
444         val &= ~(BUS_CLK_DISABLE << c->reg_shift);
445         clk_writel(val, c->reg);
446
447         spin_unlock_irqrestore(&clock_register_lock, flags);
448
449         return 0;
450 }
451
452 static void tegra20_bus_clk_disable(struct clk_hw *hw)
453 {
454         struct clk_tegra *c = to_clk_tegra(hw);
455         unsigned long flags;
456         u32 val;
457
458         spin_lock_irqsave(&clock_register_lock, flags);
459
460         val = clk_readl(c->reg);
461         val |= BUS_CLK_DISABLE << c->reg_shift;
462         clk_writel(val, c->reg);
463
464         spin_unlock_irqrestore(&clock_register_lock, flags);
465 }
466
467 static unsigned long tegra20_bus_clk_recalc_rate(struct clk_hw *hw,
468                         unsigned long prate)
469 {
470         struct clk_tegra *c = to_clk_tegra(hw);
471         u32 val = clk_readl(c->reg);
472         u64 rate = prate;
473
474         c->div = ((val >> c->reg_shift) & BUS_CLK_DIV_MASK) + 1;
475         c->mul = 1;
476
477         if (c->mul != 0 && c->div != 0) {
478                 rate *= c->mul;
479                 rate += c->div - 1; /* round up */
480                 do_div(rate, c->div);
481         }
482         return rate;
483 }
484
485 static int tegra20_bus_clk_set_rate(struct clk_hw *hw, unsigned long rate,
486                 unsigned long parent_rate)
487 {
488         struct clk_tegra *c = to_clk_tegra(hw);
489         int ret = -EINVAL;
490         unsigned long flags;
491         u32 val;
492         int i;
493
494         spin_lock_irqsave(&clock_register_lock, flags);
495
496         val = clk_readl(c->reg);
497         for (i = 1; i <= 4; i++) {
498                 if (rate == parent_rate / i) {
499                         val &= ~(BUS_CLK_DIV_MASK << c->reg_shift);
500                         val |= (i - 1) << c->reg_shift;
501                         clk_writel(val, c->reg);
502                         c->div = i;
503                         c->mul = 1;
504                         ret = 0;
505                         break;
506                 }
507         }
508
509         spin_unlock_irqrestore(&clock_register_lock, flags);
510
511         return ret;
512 }
513
514 static long tegra20_bus_clk_round_rate(struct clk_hw *hw, unsigned long rate,
515                                 unsigned long *prate)
516 {
517         unsigned long parent_rate = *prate;
518         s64 divider;
519
520         if (rate >= parent_rate)
521                 return rate;
522
523         divider = parent_rate;
524         divider += rate - 1;
525         do_div(divider, rate);
526
527         if (divider < 0)
528                 return divider;
529
530         if (divider > 4)
531                 divider = 4;
532         do_div(parent_rate, divider);
533
534         return parent_rate;
535 }
536
537 struct clk_ops tegra_bus_ops = {
538         .is_enabled = tegra20_bus_clk_is_enabled,
539         .enable = tegra20_bus_clk_enable,
540         .disable = tegra20_bus_clk_disable,
541         .set_rate = tegra20_bus_clk_set_rate,
542         .round_rate = tegra20_bus_clk_round_rate,
543         .recalc_rate = tegra20_bus_clk_recalc_rate,
544 };
545
546 /* Blink output functions */
547 static int tegra20_blink_clk_is_enabled(struct clk_hw *hw)
548 {
549         struct clk_tegra *c = to_clk_tegra(hw);
550         u32 val;
551
552         val = pmc_readl(PMC_CTRL);
553         c->state = (val & PMC_CTRL_BLINK_ENB) ? ON : OFF;
554         return c->state;
555 }
556
557 static unsigned long tegra20_blink_clk_recalc_rate(struct clk_hw *hw,
558                         unsigned long prate)
559 {
560         struct clk_tegra *c = to_clk_tegra(hw);
561         u64 rate = prate;
562         u32 val;
563
564         c->mul = 1;
565         val = pmc_readl(c->reg);
566
567         if (val & PMC_BLINK_TIMER_ENB) {
568                 unsigned int on_off;
569
570                 on_off = (val >> PMC_BLINK_TIMER_DATA_ON_SHIFT) &
571                         PMC_BLINK_TIMER_DATA_ON_MASK;
572                 val >>= PMC_BLINK_TIMER_DATA_OFF_SHIFT;
573                 val &= PMC_BLINK_TIMER_DATA_OFF_MASK;
574                 on_off += val;
575                 /* each tick in the blink timer is 4 32KHz clocks */
576                 c->div = on_off * 4;
577         } else {
578                 c->div = 1;
579         }
580
581         if (c->mul != 0 && c->div != 0) {
582                 rate *= c->mul;
583                 rate += c->div - 1; /* round up */
584                 do_div(rate, c->div);
585         }
586         return rate;
587 }
588
589 static int tegra20_blink_clk_enable(struct clk_hw *hw)
590 {
591         u32 val;
592
593         val = pmc_readl(PMC_DPD_PADS_ORIDE);
594         pmc_writel(val | PMC_DPD_PADS_ORIDE_BLINK_ENB, PMC_DPD_PADS_ORIDE);
595
596         val = pmc_readl(PMC_CTRL);
597         pmc_writel(val | PMC_CTRL_BLINK_ENB, PMC_CTRL);
598
599         return 0;
600 }
601
602 static void tegra20_blink_clk_disable(struct clk_hw *hw)
603 {
604         u32 val;
605
606         val = pmc_readl(PMC_CTRL);
607         pmc_writel(val & ~PMC_CTRL_BLINK_ENB, PMC_CTRL);
608
609         val = pmc_readl(PMC_DPD_PADS_ORIDE);
610         pmc_writel(val & ~PMC_DPD_PADS_ORIDE_BLINK_ENB, PMC_DPD_PADS_ORIDE);
611 }
612
613 static int tegra20_blink_clk_set_rate(struct clk_hw *hw, unsigned long rate,
614                 unsigned long parent_rate)
615 {
616         struct clk_tegra *c = to_clk_tegra(hw);
617
618         if (rate >= parent_rate) {
619                 c->div = 1;
620                 pmc_writel(0, c->reg);
621         } else {
622                 unsigned int on_off;
623                 u32 val;
624
625                 on_off = DIV_ROUND_UP(parent_rate / 8, rate);
626                 c->div = on_off * 8;
627
628                 val = (on_off & PMC_BLINK_TIMER_DATA_ON_MASK) <<
629                         PMC_BLINK_TIMER_DATA_ON_SHIFT;
630                 on_off &= PMC_BLINK_TIMER_DATA_OFF_MASK;
631                 on_off <<= PMC_BLINK_TIMER_DATA_OFF_SHIFT;
632                 val |= on_off;
633                 val |= PMC_BLINK_TIMER_ENB;
634                 pmc_writel(val, c->reg);
635         }
636
637         return 0;
638 }
639
640 static long tegra20_blink_clk_round_rate(struct clk_hw *hw, unsigned long rate,
641                                 unsigned long *prate)
642 {
643         int div;
644         int mul;
645         long round_rate = *prate;
646
647         mul = 1;
648
649         if (rate >= *prate) {
650                 div = 1;
651         } else {
652                 div = DIV_ROUND_UP(*prate / 8, rate);
653                 div *= 8;
654         }
655
656         round_rate *= mul;
657         round_rate += div - 1;
658         do_div(round_rate, div);
659
660         return round_rate;
661 }
662
663 struct clk_ops tegra_blink_clk_ops = {
664         .is_enabled = tegra20_blink_clk_is_enabled,
665         .enable = tegra20_blink_clk_enable,
666         .disable = tegra20_blink_clk_disable,
667         .set_rate = tegra20_blink_clk_set_rate,
668         .round_rate = tegra20_blink_clk_round_rate,
669         .recalc_rate = tegra20_blink_clk_recalc_rate,
670 };
671
672 /* PLL Functions */
673 static int tegra20_pll_clk_wait_for_lock(struct clk_tegra *c)
674 {
675         udelay(c->u.pll.lock_delay);
676         return 0;
677 }
678
679 static int tegra20_pll_clk_is_enabled(struct clk_hw *hw)
680 {
681         struct clk_tegra *c = to_clk_tegra(hw);
682         u32 val = clk_readl(c->reg + PLL_BASE);
683
684         c->state = (val & PLL_BASE_ENABLE) ? ON : OFF;
685         return c->state;
686 }
687
688 static unsigned long tegra20_pll_clk_recalc_rate(struct clk_hw *hw,
689                                 unsigned long prate)
690 {
691         struct clk_tegra *c = to_clk_tegra(hw);
692         u32 val = clk_readl(c->reg + PLL_BASE);
693         u64 rate = prate;
694
695         if (c->flags & PLL_FIXED && !(val & PLL_BASE_OVERRIDE)) {
696                 const struct clk_pll_freq_table *sel;
697                 for (sel = c->u.pll.freq_table; sel->input_rate != 0; sel++) {
698                         if (sel->input_rate == prate &&
699                                 sel->output_rate == c->u.pll.fixed_rate) {
700                                 c->mul = sel->n;
701                                 c->div = sel->m * sel->p;
702                                 break;
703                         }
704                 }
705                 pr_err("Clock %s has unknown fixed frequency\n",
706                         __clk_get_name(hw->clk));
707                 BUG();
708         } else if (val & PLL_BASE_BYPASS) {
709                 c->mul = 1;
710                 c->div = 1;
711         } else {
712                 c->mul = (val & PLL_BASE_DIVN_MASK) >> PLL_BASE_DIVN_SHIFT;
713                 c->div = (val & PLL_BASE_DIVM_MASK) >> PLL_BASE_DIVM_SHIFT;
714                 if (c->flags & PLLU)
715                         c->div *= (val & PLLU_BASE_POST_DIV) ? 1 : 2;
716                 else
717                         c->div *= (val & PLL_BASE_DIVP_MASK) ? 2 : 1;
718         }
719
720         if (c->mul != 0 && c->div != 0) {
721                 rate *= c->mul;
722                 rate += c->div - 1; /* round up */
723                 do_div(rate, c->div);
724         }
725         return rate;
726 }
727
728 static int tegra20_pll_clk_enable(struct clk_hw *hw)
729 {
730         struct clk_tegra *c = to_clk_tegra(hw);
731         u32 val;
732         pr_debug("%s on clock %s\n", __func__, __clk_get_name(hw->clk));
733
734         val = clk_readl(c->reg + PLL_BASE);
735         val &= ~PLL_BASE_BYPASS;
736         val |= PLL_BASE_ENABLE;
737         clk_writel(val, c->reg + PLL_BASE);
738
739         tegra20_pll_clk_wait_for_lock(c);
740
741         return 0;
742 }
743
744 static void tegra20_pll_clk_disable(struct clk_hw *hw)
745 {
746         struct clk_tegra *c = to_clk_tegra(hw);
747         u32 val;
748         pr_debug("%s on clock %s\n", __func__, __clk_get_name(hw->clk));
749
750         val = clk_readl(c->reg);
751         val &= ~(PLL_BASE_BYPASS | PLL_BASE_ENABLE);
752         clk_writel(val, c->reg);
753 }
754
755 static int tegra20_pll_clk_set_rate(struct clk_hw *hw, unsigned long rate,
756                 unsigned long parent_rate)
757 {
758         struct clk_tegra *c = to_clk_tegra(hw);
759         unsigned long input_rate = parent_rate;
760         const struct clk_pll_freq_table *sel;
761         u32 val;
762
763         pr_debug("%s: %s %lu\n", __func__, __clk_get_name(hw->clk), rate);
764
765         if (c->flags & PLL_FIXED) {
766                 int ret = 0;
767                 if (rate != c->u.pll.fixed_rate) {
768                         pr_err("%s: Can not change %s fixed rate %lu to %lu\n",
769                                 __func__, __clk_get_name(hw->clk),
770                                 c->u.pll.fixed_rate, rate);
771                         ret = -EINVAL;
772                 }
773                 return ret;
774         }
775
776         for (sel = c->u.pll.freq_table; sel->input_rate != 0; sel++) {
777                 if (sel->input_rate == input_rate && sel->output_rate == rate) {
778                         c->mul = sel->n;
779                         c->div = sel->m * sel->p;
780
781                         val = clk_readl(c->reg + PLL_BASE);
782                         if (c->flags & PLL_FIXED)
783                                 val |= PLL_BASE_OVERRIDE;
784                         val &= ~(PLL_BASE_DIVP_MASK | PLL_BASE_DIVN_MASK |
785                                  PLL_BASE_DIVM_MASK);
786                         val |= (sel->m << PLL_BASE_DIVM_SHIFT) |
787                                 (sel->n << PLL_BASE_DIVN_SHIFT);
788                         BUG_ON(sel->p < 1 || sel->p > 2);
789                         if (c->flags & PLLU) {
790                                 if (sel->p == 1)
791                                         val |= PLLU_BASE_POST_DIV;
792                         } else {
793                                 if (sel->p == 2)
794                                         val |= 1 << PLL_BASE_DIVP_SHIFT;
795                         }
796                         clk_writel(val, c->reg + PLL_BASE);
797
798                         if (c->flags & PLL_HAS_CPCON) {
799                                 val = clk_readl(c->reg + PLL_MISC(c));
800                                 val &= ~PLL_MISC_CPCON_MASK;
801                                 val |= sel->cpcon << PLL_MISC_CPCON_SHIFT;
802                                 clk_writel(val, c->reg + PLL_MISC(c));
803                         }
804
805                         if (c->state == ON)
806                                 tegra20_pll_clk_enable(hw);
807                         return 0;
808                 }
809         }
810         return -EINVAL;
811 }
812
813 static long tegra20_pll_clk_round_rate(struct clk_hw *hw, unsigned long rate,
814                                 unsigned long *prate)
815 {
816         struct clk_tegra *c = to_clk_tegra(hw);
817         const struct clk_pll_freq_table *sel;
818         unsigned long input_rate = *prate;
819         u64 output_rate = *prate;
820         int mul;
821         int div;
822
823         if (c->flags & PLL_FIXED)
824                 return c->u.pll.fixed_rate;
825
826         for (sel = c->u.pll.freq_table; sel->input_rate != 0; sel++)
827                 if (sel->input_rate == input_rate && sel->output_rate == rate) {
828                         mul = sel->n;
829                         div = sel->m * sel->p;
830                         break;
831                 }
832
833         if (sel->input_rate == 0)
834                 return -EINVAL;
835
836         output_rate *= mul;
837         output_rate += div - 1; /* round up */
838         do_div(output_rate, div);
839
840         return output_rate;
841 }
842
843 struct clk_ops tegra_pll_ops = {
844         .is_enabled = tegra20_pll_clk_is_enabled,
845         .enable = tegra20_pll_clk_enable,
846         .disable = tegra20_pll_clk_disable,
847         .set_rate = tegra20_pll_clk_set_rate,
848         .recalc_rate = tegra20_pll_clk_recalc_rate,
849         .round_rate = tegra20_pll_clk_round_rate,
850 };
851
852 static void tegra20_pllx_clk_init(struct clk_hw *hw)
853 {
854         struct clk_tegra *c = to_clk_tegra(hw);
855
856         if (tegra_sku_id == 7)
857                 c->max_rate = 750000000;
858 }
859
860 struct clk_ops tegra_pllx_ops = {
861         .init = tegra20_pllx_clk_init,
862         .is_enabled = tegra20_pll_clk_is_enabled,
863         .enable = tegra20_pll_clk_enable,
864         .disable = tegra20_pll_clk_disable,
865         .set_rate = tegra20_pll_clk_set_rate,
866         .recalc_rate = tegra20_pll_clk_recalc_rate,
867         .round_rate = tegra20_pll_clk_round_rate,
868 };
869
870 static int tegra20_plle_clk_enable(struct clk_hw *hw)
871 {
872         struct clk_tegra *c = to_clk_tegra(hw);
873         u32 val;
874
875         pr_debug("%s on clock %s\n", __func__, __clk_get_name(hw->clk));
876
877         mdelay(1);
878
879         val = clk_readl(c->reg + PLL_BASE);
880         if (!(val & PLLE_MISC_READY))
881                 return -EBUSY;
882
883         val = clk_readl(c->reg + PLL_BASE);
884         val |= PLL_BASE_ENABLE | PLL_BASE_BYPASS;
885         clk_writel(val, c->reg + PLL_BASE);
886
887         return 0;
888 }
889
890 struct clk_ops tegra_plle_ops = {
891         .is_enabled = tegra20_pll_clk_is_enabled,
892         .enable = tegra20_plle_clk_enable,
893         .set_rate = tegra20_pll_clk_set_rate,
894         .recalc_rate = tegra20_pll_clk_recalc_rate,
895         .round_rate = tegra20_pll_clk_round_rate,
896 };
897
898 /* Clock divider ops */
899 static int tegra20_pll_div_clk_is_enabled(struct clk_hw *hw)
900 {
901         struct clk_tegra *c = to_clk_tegra(hw);
902         u32 val = clk_readl(c->reg);
903
904         val >>= c->reg_shift;
905         c->state = (val & PLL_OUT_CLKEN) ? ON : OFF;
906         if (!(val & PLL_OUT_RESET_DISABLE))
907                 c->state = OFF;
908         return c->state;
909 }
910
911 static unsigned long tegra20_pll_div_clk_recalc_rate(struct clk_hw *hw,
912                         unsigned long prate)
913 {
914         struct clk_tegra *c = to_clk_tegra(hw);
915         u64 rate = prate;
916         u32 val = clk_readl(c->reg);
917         u32 divu71;
918
919         val >>= c->reg_shift;
920
921         if (c->flags & DIV_U71) {
922                 divu71 = (val & PLL_OUT_RATIO_MASK) >> PLL_OUT_RATIO_SHIFT;
923                 c->div = (divu71 + 2);
924                 c->mul = 2;
925         } else if (c->flags & DIV_2) {
926                 c->div = 2;
927                 c->mul = 1;
928         } else {
929                 c->div = 1;
930                 c->mul = 1;
931         }
932
933         rate *= c->mul;
934         rate += c->div - 1; /* round up */
935         do_div(rate, c->div);
936
937         return rate;
938 }
939
940 static int tegra20_pll_div_clk_enable(struct clk_hw *hw)
941 {
942         struct clk_tegra *c = to_clk_tegra(hw);
943         unsigned long flags;
944         u32 new_val;
945         u32 val;
946
947         pr_debug("%s: %s\n", __func__, __clk_get_name(hw->clk));
948
949         if (c->flags & DIV_U71) {
950                 spin_lock_irqsave(&clock_register_lock, flags);
951                 val = clk_readl(c->reg);
952                 new_val = val >> c->reg_shift;
953                 new_val &= 0xFFFF;
954
955                 new_val |= PLL_OUT_CLKEN | PLL_OUT_RESET_DISABLE;
956
957                 val &= ~(0xFFFF << c->reg_shift);
958                 val |= new_val << c->reg_shift;
959                 clk_writel(val, c->reg);
960                 spin_unlock_irqrestore(&clock_register_lock, flags);
961                 return 0;
962         } else if (c->flags & DIV_2) {
963                 BUG_ON(!(c->flags & PLLD));
964                 spin_lock_irqsave(&clock_register_lock, flags);
965                 val = clk_readl(c->reg);
966                 val &= ~PLLD_MISC_DIV_RST;
967                 clk_writel(val, c->reg);
968                 spin_unlock_irqrestore(&clock_register_lock, flags);
969                 return 0;
970         }
971         return -EINVAL;
972 }
973
974 static void tegra20_pll_div_clk_disable(struct clk_hw *hw)
975 {
976         struct clk_tegra *c = to_clk_tegra(hw);
977         unsigned long flags;
978         u32 new_val;
979         u32 val;
980
981         pr_debug("%s: %s\n", __func__, __clk_get_name(hw->clk));
982
983         if (c->flags & DIV_U71) {
984                 spin_lock_irqsave(&clock_register_lock, flags);
985                 val = clk_readl(c->reg);
986                 new_val = val >> c->reg_shift;
987                 new_val &= 0xFFFF;
988
989                 new_val &= ~(PLL_OUT_CLKEN | PLL_OUT_RESET_DISABLE);
990
991                 val &= ~(0xFFFF << c->reg_shift);
992                 val |= new_val << c->reg_shift;
993                 clk_writel(val, c->reg);
994                 spin_unlock_irqrestore(&clock_register_lock, flags);
995         } else if (c->flags & DIV_2) {
996                 BUG_ON(!(c->flags & PLLD));
997                 spin_lock_irqsave(&clock_register_lock, flags);
998                 val = clk_readl(c->reg);
999                 val |= PLLD_MISC_DIV_RST;
1000                 clk_writel(val, c->reg);
1001                 spin_unlock_irqrestore(&clock_register_lock, flags);
1002         }
1003 }
1004
1005 static int tegra20_pll_div_clk_set_rate(struct clk_hw *hw, unsigned long rate,
1006                 unsigned long parent_rate)
1007 {
1008         struct clk_tegra *c = to_clk_tegra(hw);
1009         unsigned long flags;
1010         int divider_u71;
1011         u32 new_val;
1012         u32 val;
1013
1014         pr_debug("%s: %s %lu\n", __func__, __clk_get_name(hw->clk), rate);
1015
1016         if (c->flags & DIV_U71) {
1017                 divider_u71 = clk_div71_get_divider(parent_rate, rate);
1018                 if (divider_u71 >= 0) {
1019                         spin_lock_irqsave(&clock_register_lock, flags);
1020                         val = clk_readl(c->reg);
1021                         new_val = val >> c->reg_shift;
1022                         new_val &= 0xFFFF;
1023                         if (c->flags & DIV_U71_FIXED)
1024                                 new_val |= PLL_OUT_OVERRIDE;
1025                         new_val &= ~PLL_OUT_RATIO_MASK;
1026                         new_val |= divider_u71 << PLL_OUT_RATIO_SHIFT;
1027
1028                         val &= ~(0xFFFF << c->reg_shift);
1029                         val |= new_val << c->reg_shift;
1030                         clk_writel(val, c->reg);
1031                         c->div = divider_u71 + 2;
1032                         c->mul = 2;
1033                         spin_unlock_irqrestore(&clock_register_lock, flags);
1034                         return 0;
1035                 }
1036         } else if (c->flags & DIV_2) {
1037                 if (parent_rate == rate * 2)
1038                         return 0;
1039         }
1040         return -EINVAL;
1041 }
1042
1043 static long tegra20_pll_div_clk_round_rate(struct clk_hw *hw, unsigned long rate,
1044                                 unsigned long *prate)
1045 {
1046         struct clk_tegra *c = to_clk_tegra(hw);
1047         unsigned long parent_rate = *prate;
1048         int divider;
1049
1050         pr_debug("%s: %s %lu\n", __func__, __clk_get_name(hw->clk), rate);
1051
1052         if (c->flags & DIV_U71) {
1053                 divider = clk_div71_get_divider(parent_rate, rate);
1054                 if (divider < 0)
1055                         return divider;
1056                 return DIV_ROUND_UP(parent_rate * 2, divider + 2);
1057         } else if (c->flags & DIV_2) {
1058                 return DIV_ROUND_UP(parent_rate, 2);
1059         }
1060         return -EINVAL;
1061 }
1062
1063 struct clk_ops tegra_pll_div_ops = {
1064         .is_enabled = tegra20_pll_div_clk_is_enabled,
1065         .enable = tegra20_pll_div_clk_enable,
1066         .disable = tegra20_pll_div_clk_disable,
1067         .set_rate = tegra20_pll_div_clk_set_rate,
1068         .round_rate = tegra20_pll_div_clk_round_rate,
1069         .recalc_rate = tegra20_pll_div_clk_recalc_rate,
1070 };
1071
1072 /* Periph clk ops */
1073
1074 static int tegra20_periph_clk_is_enabled(struct clk_hw *hw)
1075 {
1076         struct clk_tegra *c = to_clk_tegra(hw);
1077
1078         c->state = ON;
1079
1080         if (!c->u.periph.clk_num)
1081                 goto out;
1082
1083         if (!(clk_readl(CLK_OUT_ENB + PERIPH_CLK_TO_ENB_REG(c)) &
1084                         PERIPH_CLK_TO_ENB_BIT(c)))
1085                 c->state = OFF;
1086
1087         if (!(c->flags & PERIPH_NO_RESET))
1088                 if (clk_readl(RST_DEVICES + PERIPH_CLK_TO_ENB_REG(c)) &
1089                                 PERIPH_CLK_TO_ENB_BIT(c))
1090                         c->state = OFF;
1091
1092 out:
1093         return c->state;
1094 }
1095
1096 static int tegra20_periph_clk_enable(struct clk_hw *hw)
1097 {
1098         struct clk_tegra *c = to_clk_tegra(hw);
1099         unsigned long flags;
1100         u32 val;
1101
1102         pr_debug("%s on clock %s\n", __func__, __clk_get_name(hw->clk));
1103
1104         if (!c->u.periph.clk_num)
1105                 return 0;
1106
1107         tegra_periph_clk_enable_refcount[c->u.periph.clk_num]++;
1108         if (tegra_periph_clk_enable_refcount[c->u.periph.clk_num] > 1)
1109                 return 0;
1110
1111         spin_lock_irqsave(&clock_register_lock, flags);
1112
1113         clk_writel(PERIPH_CLK_TO_ENB_BIT(c),
1114                 CLK_OUT_ENB_SET + PERIPH_CLK_TO_ENB_SET_REG(c));
1115         if (!(c->flags & PERIPH_NO_RESET) && !(c->flags & PERIPH_MANUAL_RESET))
1116                 clk_writel(PERIPH_CLK_TO_ENB_BIT(c),
1117                         RST_DEVICES_CLR + PERIPH_CLK_TO_ENB_SET_REG(c));
1118         if (c->flags & PERIPH_EMC_ENB) {
1119                 /* The EMC peripheral clock has 2 extra enable bits */
1120                 /* FIXME: Do they need to be disabled? */
1121                 val = clk_readl(c->reg);
1122                 val |= 0x3 << 24;
1123                 clk_writel(val, c->reg);
1124         }
1125
1126         spin_unlock_irqrestore(&clock_register_lock, flags);
1127
1128         return 0;
1129 }
1130
1131 static void tegra20_periph_clk_disable(struct clk_hw *hw)
1132 {
1133         struct clk_tegra *c = to_clk_tegra(hw);
1134         unsigned long flags;
1135
1136         pr_debug("%s on clock %s\n", __func__, __clk_get_name(hw->clk));
1137
1138         if (!c->u.periph.clk_num)
1139                 return;
1140
1141         tegra_periph_clk_enable_refcount[c->u.periph.clk_num]--;
1142
1143         if (tegra_periph_clk_enable_refcount[c->u.periph.clk_num] > 0)
1144                 return;
1145
1146         spin_lock_irqsave(&clock_register_lock, flags);
1147
1148         clk_writel(PERIPH_CLK_TO_ENB_BIT(c),
1149                 CLK_OUT_ENB_CLR + PERIPH_CLK_TO_ENB_SET_REG(c));
1150
1151         spin_unlock_irqrestore(&clock_register_lock, flags);
1152 }
1153
1154 void tegra2_periph_clk_reset(struct clk_hw *hw, bool assert)
1155 {
1156         struct clk_tegra *c = to_clk_tegra(hw);
1157         unsigned long base = assert ? RST_DEVICES_SET : RST_DEVICES_CLR;
1158
1159         pr_debug("%s %s on clock %s\n", __func__,
1160                 assert ? "assert" : "deassert", __clk_get_name(hw->clk));
1161
1162         BUG_ON(!c->u.periph.clk_num);
1163
1164         if (!(c->flags & PERIPH_NO_RESET))
1165                 clk_writel(PERIPH_CLK_TO_ENB_BIT(c),
1166                            base + PERIPH_CLK_TO_ENB_SET_REG(c));
1167 }
1168
1169 static int tegra20_periph_clk_set_parent(struct clk_hw *hw, u8 index)
1170 {
1171         struct clk_tegra *c = to_clk_tegra(hw);
1172         u32 val;
1173         u32 mask;
1174         u32 shift;
1175
1176         pr_debug("%s: %s %d\n", __func__, __clk_get_name(hw->clk), index);
1177
1178         if (c->flags & MUX_PWM) {
1179                 shift = PERIPH_CLK_SOURCE_PWM_SHIFT;
1180                 mask = PERIPH_CLK_SOURCE_PWM_MASK;
1181         } else {
1182                 shift = PERIPH_CLK_SOURCE_SHIFT;
1183                 mask = PERIPH_CLK_SOURCE_MASK;
1184         }
1185
1186         val = clk_readl(c->reg);
1187         val &= ~mask;
1188         val |= (index) << shift;
1189
1190         clk_writel(val, c->reg);
1191
1192         return 0;
1193 }
1194
1195 static u8 tegra20_periph_clk_get_parent(struct clk_hw *hw)
1196 {
1197         struct clk_tegra *c = to_clk_tegra(hw);
1198         u32 val = clk_readl(c->reg);
1199         u32 mask;
1200         u32 shift;
1201
1202         if (c->flags & MUX_PWM) {
1203                 shift = PERIPH_CLK_SOURCE_PWM_SHIFT;
1204                 mask = PERIPH_CLK_SOURCE_PWM_MASK;
1205         } else {
1206                 shift = PERIPH_CLK_SOURCE_SHIFT;
1207                 mask = PERIPH_CLK_SOURCE_MASK;
1208         }
1209
1210         if (c->flags & MUX)
1211                 return (val & mask) >> shift;
1212         else
1213                 return 0;
1214 }
1215
1216 static unsigned long tegra20_periph_clk_recalc_rate(struct clk_hw *hw,
1217                         unsigned long prate)
1218 {
1219         struct clk_tegra *c = to_clk_tegra(hw);
1220         unsigned long rate = prate;
1221         u32 val = clk_readl(c->reg);
1222
1223         if (c->flags & DIV_U71) {
1224                 u32 divu71 = val & PERIPH_CLK_SOURCE_DIVU71_MASK;
1225                 c->div = divu71 + 2;
1226                 c->mul = 2;
1227         } else if (c->flags & DIV_U16) {
1228                 u32 divu16 = val & PERIPH_CLK_SOURCE_DIVU16_MASK;
1229                 c->div = divu16 + 1;
1230                 c->mul = 1;
1231         } else {
1232                 c->div = 1;
1233                 c->mul = 1;
1234                 return rate;
1235         }
1236
1237         if (c->mul != 0 && c->div != 0) {
1238                 rate *= c->mul;
1239                 rate += c->div - 1; /* round up */
1240                 do_div(rate, c->div);
1241         }
1242
1243         return rate;
1244 }
1245
1246 static int tegra20_periph_clk_set_rate(struct clk_hw *hw, unsigned long rate,
1247                 unsigned long parent_rate)
1248 {
1249         struct clk_tegra *c = to_clk_tegra(hw);
1250         u32 val;
1251         int divider;
1252
1253         val = clk_readl(c->reg);
1254
1255         if (c->flags & DIV_U71) {
1256                 divider = clk_div71_get_divider(parent_rate, rate);
1257
1258                 if (divider >= 0) {
1259                         val = clk_readl(c->reg);
1260                         val &= ~PERIPH_CLK_SOURCE_DIVU71_MASK;
1261                         val |= divider;
1262                         clk_writel(val, c->reg);
1263                         c->div = divider + 2;
1264                         c->mul = 2;
1265                         return 0;
1266                 }
1267         } else if (c->flags & DIV_U16) {
1268                 divider = clk_div16_get_divider(parent_rate, rate);
1269                 if (divider >= 0) {
1270                         val = clk_readl(c->reg);
1271                         val &= ~PERIPH_CLK_SOURCE_DIVU16_MASK;
1272                         val |= divider;
1273                         clk_writel(val, c->reg);
1274                         c->div = divider + 1;
1275                         c->mul = 1;
1276                         return 0;
1277                 }
1278         } else if (parent_rate <= rate) {
1279                 c->div = 1;
1280                 c->mul = 1;
1281                 return 0;
1282         }
1283
1284         return -EINVAL;
1285 }
1286
1287 static long tegra20_periph_clk_round_rate(struct clk_hw *hw,
1288         unsigned long rate, unsigned long *prate)
1289 {
1290         struct clk_tegra *c = to_clk_tegra(hw);
1291         unsigned long parent_rate = __clk_get_rate(__clk_get_parent(hw->clk));
1292         int divider;
1293
1294         pr_debug("%s: %s %lu\n", __func__, __clk_get_name(hw->clk), rate);
1295
1296         if (prate)
1297                 parent_rate = *prate;
1298
1299         if (c->flags & DIV_U71) {
1300                 divider = clk_div71_get_divider(parent_rate, rate);
1301                 if (divider < 0)
1302                         return divider;
1303
1304                 return DIV_ROUND_UP(parent_rate * 2, divider + 2);
1305         } else if (c->flags & DIV_U16) {
1306                 divider = clk_div16_get_divider(parent_rate, rate);
1307                 if (divider < 0)
1308                         return divider;
1309                 return DIV_ROUND_UP(parent_rate, divider + 1);
1310         }
1311         return -EINVAL;
1312 }
1313
1314 struct clk_ops tegra_periph_clk_ops = {
1315         .is_enabled = tegra20_periph_clk_is_enabled,
1316         .enable = tegra20_periph_clk_enable,
1317         .disable = tegra20_periph_clk_disable,
1318         .set_parent = tegra20_periph_clk_set_parent,
1319         .get_parent = tegra20_periph_clk_get_parent,
1320         .set_rate = tegra20_periph_clk_set_rate,
1321         .round_rate = tegra20_periph_clk_round_rate,
1322         .recalc_rate = tegra20_periph_clk_recalc_rate,
1323 };
1324
1325 /* External memory controller clock ops */
1326 static void tegra20_emc_clk_init(struct clk_hw *hw)
1327 {
1328         struct clk_tegra *c = to_clk_tegra(hw);
1329         c->max_rate = __clk_get_rate(hw->clk);
1330 }
1331
1332 static long tegra20_emc_clk_round_rate(struct clk_hw *hw, unsigned long rate,
1333                                 unsigned long *prate)
1334 {
1335         struct clk_tegra *c = to_clk_tegra(hw);
1336         long emc_rate;
1337         long clk_rate;
1338
1339         /*
1340          * The slowest entry in the EMC clock table that is at least as
1341          * fast as rate.
1342          */
1343         emc_rate = tegra_emc_round_rate(rate);
1344         if (emc_rate < 0)
1345                 return c->max_rate;
1346
1347         /*
1348          * The fastest rate the PLL will generate that is at most the
1349          * requested rate.
1350          */
1351         clk_rate = tegra20_periph_clk_round_rate(hw, emc_rate, NULL);
1352
1353         /*
1354          * If this fails, and emc_rate > clk_rate, it's because the maximum
1355          * rate in the EMC tables is larger than the maximum rate of the EMC
1356          * clock. The EMC clock's max rate is the rate it was running when the
1357          * kernel booted. Such a mismatch is probably due to using the wrong
1358          * BCT, i.e. using a Tegra20 BCT with an EMC table written for Tegra25.
1359          */
1360         WARN_ONCE(emc_rate != clk_rate,
1361                 "emc_rate %ld != clk_rate %ld",
1362                 emc_rate, clk_rate);
1363
1364         return emc_rate;
1365 }
1366
1367 static int tegra20_emc_clk_set_rate(struct clk_hw *hw, unsigned long rate,
1368                 unsigned long parent_rate)
1369 {
1370         int ret;
1371
1372         /*
1373          * The Tegra2 memory controller has an interlock with the clock
1374          * block that allows memory shadowed registers to be updated,
1375          * and then transfer them to the main registers at the same
1376          * time as the clock update without glitches.
1377          */
1378         ret = tegra_emc_set_rate(rate);
1379         if (ret < 0)
1380                 return ret;
1381
1382         ret = tegra20_periph_clk_set_rate(hw, rate, parent_rate);
1383         udelay(1);
1384
1385         return ret;
1386 }
1387
1388 struct clk_ops tegra_emc_clk_ops = {
1389         .init = tegra20_emc_clk_init,
1390         .is_enabled = tegra20_periph_clk_is_enabled,
1391         .enable = tegra20_periph_clk_enable,
1392         .disable = tegra20_periph_clk_disable,
1393         .set_parent = tegra20_periph_clk_set_parent,
1394         .get_parent = tegra20_periph_clk_get_parent,
1395         .set_rate = tegra20_emc_clk_set_rate,
1396         .round_rate = tegra20_emc_clk_round_rate,
1397         .recalc_rate = tegra20_periph_clk_recalc_rate,
1398 };
1399
1400 /* Clock doubler ops */
1401 static int tegra20_clk_double_is_enabled(struct clk_hw *hw)
1402 {
1403         struct clk_tegra *c = to_clk_tegra(hw);
1404
1405         c->state = ON;
1406
1407         if (!c->u.periph.clk_num)
1408                 goto out;
1409
1410         if (!(clk_readl(CLK_OUT_ENB + PERIPH_CLK_TO_ENB_REG(c)) &
1411                         PERIPH_CLK_TO_ENB_BIT(c)))
1412                 c->state = OFF;
1413
1414 out:
1415         return c->state;
1416 };
1417
1418 static unsigned long tegra20_clk_double_recalc_rate(struct clk_hw *hw,
1419                         unsigned long prate)
1420 {
1421         struct clk_tegra *c = to_clk_tegra(hw);
1422         u64 rate = prate;
1423
1424         c->mul = 2;
1425         c->div = 1;
1426
1427         rate *= c->mul;
1428         rate += c->div - 1; /* round up */
1429         do_div(rate, c->div);
1430
1431         return rate;
1432 }
1433
1434 static long tegra20_clk_double_round_rate(struct clk_hw *hw, unsigned long rate,
1435                                 unsigned long *prate)
1436 {
1437         unsigned long output_rate = *prate;
1438
1439         do_div(output_rate, 2);
1440         return output_rate;
1441 }
1442
1443 static int tegra20_clk_double_set_rate(struct clk_hw *hw, unsigned long rate,
1444                 unsigned long parent_rate)
1445 {
1446         if (rate != 2 * parent_rate)
1447                 return -EINVAL;
1448         return 0;
1449 }
1450
1451 struct clk_ops tegra_clk_double_ops = {
1452         .is_enabled = tegra20_clk_double_is_enabled,
1453         .enable = tegra20_periph_clk_enable,
1454         .disable = tegra20_periph_clk_disable,
1455         .set_rate = tegra20_clk_double_set_rate,
1456         .recalc_rate = tegra20_clk_double_recalc_rate,
1457         .round_rate = tegra20_clk_double_round_rate,
1458 };
1459
1460 /* Audio sync clock ops */
1461 static int tegra20_audio_sync_clk_is_enabled(struct clk_hw *hw)
1462 {
1463         struct clk_tegra *c = to_clk_tegra(hw);
1464         u32 val = clk_readl(c->reg);
1465
1466         c->state = (val & (1<<4)) ? OFF : ON;
1467         return c->state;
1468 }
1469
1470 static int tegra20_audio_sync_clk_enable(struct clk_hw *hw)
1471 {
1472         struct clk_tegra *c = to_clk_tegra(hw);
1473
1474         clk_writel(0, c->reg);
1475         return 0;
1476 }
1477
1478 static void tegra20_audio_sync_clk_disable(struct clk_hw *hw)
1479 {
1480         struct clk_tegra *c = to_clk_tegra(hw);
1481         clk_writel(1, c->reg);
1482 }
1483
1484 static u8 tegra20_audio_sync_clk_get_parent(struct clk_hw *hw)
1485 {
1486         struct clk_tegra *c = to_clk_tegra(hw);
1487         u32 val = clk_readl(c->reg);
1488         int source;
1489
1490         source = val & 0xf;
1491         return source;
1492 }
1493
1494 static int tegra20_audio_sync_clk_set_parent(struct clk_hw *hw, u8 index)
1495 {
1496         struct clk_tegra *c = to_clk_tegra(hw);
1497         u32 val;
1498
1499         val = clk_readl(c->reg);
1500         val &= ~0xf;
1501         val |= index;
1502
1503         clk_writel(val, c->reg);
1504
1505         return 0;
1506 }
1507
1508 struct clk_ops tegra_audio_sync_clk_ops = {
1509         .is_enabled = tegra20_audio_sync_clk_is_enabled,
1510         .enable = tegra20_audio_sync_clk_enable,
1511         .disable = tegra20_audio_sync_clk_disable,
1512         .set_parent = tegra20_audio_sync_clk_set_parent,
1513         .get_parent = tegra20_audio_sync_clk_get_parent,
1514 };
1515
1516 /* cdev1 and cdev2 (dap_mclk1 and dap_mclk2) ops */
1517
1518 static int tegra20_cdev_clk_is_enabled(struct clk_hw *hw)
1519 {
1520         struct clk_tegra *c = to_clk_tegra(hw);
1521         /* We could un-tristate the cdev1 or cdev2 pingroup here; this is
1522          * currently done in the pinmux code. */
1523         c->state = ON;
1524
1525         BUG_ON(!c->u.periph.clk_num);
1526
1527         if (!(clk_readl(CLK_OUT_ENB + PERIPH_CLK_TO_ENB_REG(c)) &
1528                         PERIPH_CLK_TO_ENB_BIT(c)))
1529                 c->state = OFF;
1530         return c->state;
1531 }
1532
1533 static int tegra20_cdev_clk_enable(struct clk_hw *hw)
1534 {
1535         struct clk_tegra *c = to_clk_tegra(hw);
1536         BUG_ON(!c->u.periph.clk_num);
1537
1538         clk_writel(PERIPH_CLK_TO_ENB_BIT(c),
1539                 CLK_OUT_ENB_SET + PERIPH_CLK_TO_ENB_SET_REG(c));
1540         return 0;
1541 }
1542
1543 static void tegra20_cdev_clk_disable(struct clk_hw *hw)
1544 {
1545         struct clk_tegra *c = to_clk_tegra(hw);
1546         BUG_ON(!c->u.periph.clk_num);
1547
1548         clk_writel(PERIPH_CLK_TO_ENB_BIT(c),
1549                 CLK_OUT_ENB_CLR + PERIPH_CLK_TO_ENB_SET_REG(c));
1550 }
1551
1552 static unsigned long tegra20_cdev_recalc_rate(struct clk_hw *hw,
1553                         unsigned long prate)
1554 {
1555         return to_clk_tegra(hw)->fixed_rate;
1556 }
1557
1558 struct clk_ops tegra_cdev_clk_ops = {
1559         .is_enabled = tegra20_cdev_clk_is_enabled,
1560         .enable = tegra20_cdev_clk_enable,
1561         .disable = tegra20_cdev_clk_disable,
1562         .recalc_rate = tegra20_cdev_recalc_rate,
1563 };
1564
1565 /* Tegra20 CPU clock and reset control functions */
1566 static void tegra20_wait_cpu_in_reset(u32 cpu)
1567 {
1568         unsigned int reg;
1569
1570         do {
1571                 reg = readl(reg_clk_base +
1572                             TEGRA_CLK_RST_CONTROLLER_RST_CPU_CMPLX_SET);
1573                 cpu_relax();
1574         } while (!(reg & (1 << cpu)));  /* check CPU been reset or not */
1575
1576         return;
1577 }
1578
1579 static void tegra20_put_cpu_in_reset(u32 cpu)
1580 {
1581         writel(CPU_RESET(cpu),
1582                reg_clk_base + TEGRA_CLK_RST_CONTROLLER_RST_CPU_CMPLX_SET);
1583         dmb();
1584 }
1585
1586 static void tegra20_cpu_out_of_reset(u32 cpu)
1587 {
1588         writel(CPU_RESET(cpu),
1589                reg_clk_base + TEGRA_CLK_RST_CONTROLLER_RST_CPU_CMPLX_CLR);
1590         wmb();
1591 }
1592
1593 static void tegra20_enable_cpu_clock(u32 cpu)
1594 {
1595         unsigned int reg;
1596
1597         reg = readl(reg_clk_base + TEGRA_CLK_RST_CONTROLLER_CLK_CPU_CMPLX);
1598         writel(reg & ~CPU_CLOCK(cpu),
1599                reg_clk_base + TEGRA_CLK_RST_CONTROLLER_CLK_CPU_CMPLX);
1600         barrier();
1601         reg = readl(reg_clk_base + TEGRA_CLK_RST_CONTROLLER_CLK_CPU_CMPLX);
1602 }
1603
1604 static void tegra20_disable_cpu_clock(u32 cpu)
1605 {
1606         unsigned int reg;
1607
1608         reg = readl(reg_clk_base + TEGRA_CLK_RST_CONTROLLER_CLK_CPU_CMPLX);
1609         writel(reg | CPU_CLOCK(cpu),
1610                reg_clk_base + TEGRA_CLK_RST_CONTROLLER_CLK_CPU_CMPLX);
1611 }
1612
1613 static struct tegra_cpu_car_ops tegra20_cpu_car_ops = {
1614         .wait_for_reset = tegra20_wait_cpu_in_reset,
1615         .put_in_reset   = tegra20_put_cpu_in_reset,
1616         .out_of_reset   = tegra20_cpu_out_of_reset,
1617         .enable_clock   = tegra20_enable_cpu_clock,
1618         .disable_clock  = tegra20_disable_cpu_clock,
1619 };
1620
1621 void __init tegra20_cpu_car_ops_init(void)
1622 {
1623         tegra_cpu_car_ops = &tegra20_cpu_car_ops;
1624 }