2 * arch/arm/mach-tegra/tegra2_clocks.c
4 * Copyright (C) 2010 Google, Inc.
7 * Colin Cross <ccross@google.com>
9 * This software is licensed under the terms of the GNU General Public
10 * License version 2, as published by the Free Software Foundation, and
11 * may be copied, distributed, and modified under those terms.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
20 #include <linux/kernel.h>
21 #include <linux/module.h>
22 #include <linux/list.h>
23 #include <linux/spinlock.h>
24 #include <linux/delay.h>
26 #include <linux/hrtimer.h>
28 #include <asm/clkdev.h>
30 #include <mach/iomap.h>
34 #define RST_DEVICES 0x004
35 #define RST_DEVICES_SET 0x300
36 #define RST_DEVICES_CLR 0x304
38 #define CLK_OUT_ENB 0x010
39 #define CLK_OUT_ENB_SET 0x320
40 #define CLK_OUT_ENB_CLR 0x324
43 #define OSC_CTRL_OSC_FREQ_MASK (3<<30)
44 #define OSC_CTRL_OSC_FREQ_13MHZ (0<<30)
45 #define OSC_CTRL_OSC_FREQ_19_2MHZ (1<<30)
46 #define OSC_CTRL_OSC_FREQ_12MHZ (2<<30)
47 #define OSC_CTRL_OSC_FREQ_26MHZ (3<<30)
49 #define OSC_FREQ_DET 0x58
50 #define OSC_FREQ_DET_TRIG (1<<31)
52 #define OSC_FREQ_DET_STATUS 0x5C
53 #define OSC_FREQ_DET_BUSY (1<<31)
54 #define OSC_FREQ_DET_CNT_MASK 0xFFFF
56 #define PERIPH_CLK_SOURCE_MASK (3<<30)
57 #define PERIPH_CLK_SOURCE_SHIFT 30
58 #define PERIPH_CLK_SOURCE_ENABLE (1<<28)
59 #define PERIPH_CLK_SOURCE_DIV_MASK 0xFF
60 #define PERIPH_CLK_SOURCE_DIV_SHIFT 0
63 #define PLL_BASE_BYPASS (1<<31)
64 #define PLL_BASE_ENABLE (1<<30)
65 #define PLL_BASE_REF_ENABLE (1<<29)
66 #define PLL_BASE_OVERRIDE (1<<28)
67 #define PLL_BASE_LOCK (1<<27)
68 #define PLL_BASE_DIVP_MASK (0x7<<20)
69 #define PLL_BASE_DIVP_SHIFT 20
70 #define PLL_BASE_DIVN_MASK (0x3FF<<8)
71 #define PLL_BASE_DIVN_SHIFT 8
72 #define PLL_BASE_DIVM_MASK (0x1F)
73 #define PLL_BASE_DIVM_SHIFT 0
75 #define PLL_OUT_RATIO_MASK (0xFF<<8)
76 #define PLL_OUT_RATIO_SHIFT 8
77 #define PLL_OUT_OVERRIDE (1<<2)
78 #define PLL_OUT_CLKEN (1<<1)
79 #define PLL_OUT_RESET_DISABLE (1<<0)
81 #define PLL_MISC(c) (((c)->flags & PLL_ALT_MISC_REG) ? 0x4 : 0xc)
82 #define PLL_MISC_DCCON_SHIFT 20
83 #define PLL_MISC_LOCK_ENABLE (1<<18)
84 #define PLL_MISC_CPCON_SHIFT 8
85 #define PLL_MISC_CPCON_MASK (0xF<<PLL_MISC_CPCON_SHIFT)
86 #define PLL_MISC_LFCON_SHIFT 4
87 #define PLL_MISC_LFCON_MASK (0xF<<PLL_MISC_LFCON_SHIFT)
88 #define PLL_MISC_VCOCON_SHIFT 0
89 #define PLL_MISC_VCOCON_MASK (0xF<<PLL_MISC_VCOCON_SHIFT)
91 #define PLLD_MISC_CLKENABLE (1<<30)
92 #define PLLD_MISC_DIV_RST (1<<23)
93 #define PLLD_MISC_DCCON_SHIFT 12
95 #define PERIPH_CLK_TO_ENB_REG(c) ((c->clk_num / 32) * 4)
96 #define PERIPH_CLK_TO_ENB_SET_REG(c) ((c->clk_num / 32) * 8)
97 #define PERIPH_CLK_TO_ENB_BIT(c) (1 << (c->clk_num % 32))
99 #define SUPER_CLK_MUX 0x00
100 #define SUPER_STATE_SHIFT 28
101 #define SUPER_STATE_MASK (0xF << SUPER_STATE_SHIFT)
102 #define SUPER_STATE_STANDBY (0x0 << SUPER_STATE_SHIFT)
103 #define SUPER_STATE_IDLE (0x1 << SUPER_STATE_SHIFT)
104 #define SUPER_STATE_RUN (0x2 << SUPER_STATE_SHIFT)
105 #define SUPER_STATE_IRQ (0x3 << SUPER_STATE_SHIFT)
106 #define SUPER_STATE_FIQ (0x4 << SUPER_STATE_SHIFT)
107 #define SUPER_SOURCE_MASK 0xF
108 #define SUPER_FIQ_SOURCE_SHIFT 12
109 #define SUPER_IRQ_SOURCE_SHIFT 8
110 #define SUPER_RUN_SOURCE_SHIFT 4
111 #define SUPER_IDLE_SOURCE_SHIFT 0
113 #define SUPER_CLK_DIVIDER 0x04
115 #define BUS_CLK_DISABLE (1<<3)
116 #define BUS_CLK_DIV_MASK 0x3
118 static void __iomem
*reg_clk_base
= IO_ADDRESS(TEGRA_CLK_RESET_BASE
);
120 #define clk_writel(value, reg) \
121 __raw_writel(value, (u32)reg_clk_base + (reg))
122 #define clk_readl(reg) \
123 __raw_readl((u32)reg_clk_base + (reg))
125 unsigned long clk_measure_input_freq(void)
127 u32 clock_autodetect
;
128 clk_writel(OSC_FREQ_DET_TRIG
| 1, OSC_FREQ_DET
);
129 do {} while (clk_readl(OSC_FREQ_DET_STATUS
) & OSC_FREQ_DET_BUSY
);
130 clock_autodetect
= clk_readl(OSC_FREQ_DET_STATUS
);
131 if (clock_autodetect
>= 732 - 3 && clock_autodetect
<= 732 + 3) {
133 } else if (clock_autodetect
>= 794 - 3 && clock_autodetect
<= 794 + 3) {
135 } else if (clock_autodetect
>= 1172 - 3 && clock_autodetect
<= 1172 + 3) {
137 } else if (clock_autodetect
>= 1587 - 3 && clock_autodetect
<= 1587 + 3) {
140 pr_err("%s: Unexpected clock autodetect value %d", __func__
, clock_autodetect
);
146 static int clk_div71_get_divider(struct clk
*c
, unsigned long rate
)
148 unsigned long divider_u71
;
150 divider_u71
= DIV_ROUND_UP(c
->rate
* 2, rate
);
152 if (divider_u71
- 2 > 255 || divider_u71
- 2 < 0)
155 return divider_u71
- 2;
158 static unsigned long tegra2_clk_recalculate_rate(struct clk
*c
)
161 rate
= c
->parent
->rate
;
163 if (c
->mul
!= 0 && c
->div
!= 0)
164 c
->rate
= rate
* c
->mul
/ c
->div
;
171 /* clk_m functions */
172 static unsigned long tegra2_clk_m_autodetect_rate(struct clk
*c
)
174 u32 auto_clock_control
= clk_readl(OSC_CTRL
) & ~OSC_CTRL_OSC_FREQ_MASK
;
176 c
->rate
= clk_measure_input_freq();
179 auto_clock_control
|= OSC_CTRL_OSC_FREQ_12MHZ
;
182 auto_clock_control
|= OSC_CTRL_OSC_FREQ_13MHZ
;
185 auto_clock_control
|= OSC_CTRL_OSC_FREQ_19_2MHZ
;
188 auto_clock_control
|= OSC_CTRL_OSC_FREQ_26MHZ
;
191 pr_err("%s: Unexpected clock rate %ld", __func__
, c
->rate
);
194 clk_writel(auto_clock_control
, OSC_CTRL
);
198 static void tegra2_clk_m_init(struct clk
*c
)
200 pr_debug("%s on clock %s\n", __func__
, c
->name
);
201 tegra2_clk_m_autodetect_rate(c
);
204 static int tegra2_clk_m_enable(struct clk
*c
)
206 pr_debug("%s on clock %s\n", __func__
, c
->name
);
210 static void tegra2_clk_m_disable(struct clk
*c
)
212 pr_debug("%s on clock %s\n", __func__
, c
->name
);
216 static struct clk_ops tegra_clk_m_ops
= {
217 .init
= tegra2_clk_m_init
,
218 .enable
= tegra2_clk_m_enable
,
219 .disable
= tegra2_clk_m_disable
,
222 /* super clock functions */
223 /* "super clocks" on tegra have two-stage muxes and a clock skipping
224 * super divider. We will ignore the clock skipping divider, since we
225 * can't lower the voltage when using the clock skip, but we can if we
226 * lower the PLL frequency.
228 static void tegra2_super_clk_init(struct clk
*c
)
233 const struct clk_mux_sel
*sel
;
234 val
= clk_readl(c
->reg
+ SUPER_CLK_MUX
);
236 BUG_ON(((val
& SUPER_STATE_MASK
) != SUPER_STATE_RUN
) &&
237 ((val
& SUPER_STATE_MASK
) != SUPER_STATE_IDLE
));
238 shift
= ((val
& SUPER_STATE_MASK
) == SUPER_STATE_IDLE
) ?
239 SUPER_IDLE_SOURCE_SHIFT
: SUPER_RUN_SOURCE_SHIFT
;
240 source
= (val
>> shift
) & SUPER_SOURCE_MASK
;
241 for (sel
= c
->inputs
; sel
->input
!= NULL
; sel
++) {
242 if (sel
->value
== source
)
245 BUG_ON(sel
->input
== NULL
);
246 c
->parent
= sel
->input
;
247 tegra2_clk_recalculate_rate(c
);
250 static int tegra2_super_clk_enable(struct clk
*c
)
252 clk_writel(0, c
->reg
+ SUPER_CLK_DIVIDER
);
256 static void tegra2_super_clk_disable(struct clk
*c
)
258 pr_debug("%s on clock %s\n", __func__
, c
->name
);
260 /* oops - don't disable the CPU clock! */
264 static int tegra2_super_clk_set_parent(struct clk
*c
, struct clk
*p
)
267 const struct clk_mux_sel
*sel
;
269 val
= clk_readl(c
->reg
+ SUPER_CLK_MUX
);;
270 BUG_ON(((val
& SUPER_STATE_MASK
) != SUPER_STATE_RUN
) &&
271 ((val
& SUPER_STATE_MASK
) != SUPER_STATE_IDLE
));
272 shift
= ((val
& SUPER_STATE_MASK
) == SUPER_STATE_IDLE
) ?
273 SUPER_IDLE_SOURCE_SHIFT
: SUPER_RUN_SOURCE_SHIFT
;
274 for (sel
= c
->inputs
; sel
->input
!= NULL
; sel
++) {
275 if (sel
->input
== p
) {
277 val
&= ~(SUPER_SOURCE_MASK
<< shift
);
278 val
|= sel
->value
<< shift
;
279 clk_writel(val
, c
->reg
);
280 c
->rate
= c
->parent
->rate
;
287 static struct clk_ops tegra_super_ops
= {
288 .init
= tegra2_super_clk_init
,
289 .enable
= tegra2_super_clk_enable
,
290 .disable
= tegra2_super_clk_disable
,
291 .set_parent
= tegra2_super_clk_set_parent
,
292 .recalculate_rate
= tegra2_clk_recalculate_rate
,
295 /* bus clock functions */
296 static void tegra2_bus_clk_init(struct clk
*c
)
298 u32 val
= clk_readl(c
->reg
);
299 c
->state
= ((val
>> c
->reg_shift
) & BUS_CLK_DISABLE
) ? OFF
: ON
;
300 c
->div
= ((val
>> c
->reg_shift
) & BUS_CLK_DIV_MASK
) + 1;
302 tegra2_clk_recalculate_rate(c
);
305 static int tegra2_bus_clk_enable(struct clk
*c
)
307 u32 val
= clk_readl(c
->reg
);
308 val
&= ~(BUS_CLK_DISABLE
<< c
->reg_shift
);
309 clk_writel(val
, c
->reg
);
313 static void tegra2_bus_clk_disable(struct clk
*c
)
315 u32 val
= clk_readl(c
->reg
);
316 val
|= BUS_CLK_DISABLE
<< c
->reg_shift
;
317 clk_writel(val
, c
->reg
);
320 static int tegra2_bus_clk_set_rate(struct clk
*c
, unsigned long rate
)
322 u32 val
= clk_readl(c
->reg
);
323 unsigned long parent_rate
= c
->parent
->rate
;
325 for (i
= 1; i
<= 4; i
++) {
326 if (rate
== parent_rate
/ i
) {
327 val
&= ~(BUS_CLK_DIV_MASK
<< c
->reg_shift
);
328 val
|= (i
- 1) << c
->reg_shift
;
329 clk_writel(val
, c
->reg
);
338 static struct clk_ops tegra_bus_ops
= {
339 .init
= tegra2_bus_clk_init
,
340 .enable
= tegra2_bus_clk_enable
,
341 .disable
= tegra2_bus_clk_disable
,
342 .set_rate
= tegra2_bus_clk_set_rate
,
343 .recalculate_rate
= tegra2_clk_recalculate_rate
,
347 static unsigned long tegra2_pll_clk_recalculate_rate(struct clk
*c
)
350 rate
= c
->parent
->rate
;
359 static int tegra2_pll_clk_wait_for_lock(struct clk
*c
)
363 before
= ktime_get();
364 while (!(clk_readl(c
->reg
+ PLL_BASE
) & PLL_BASE_LOCK
)) {
365 if (ktime_us_delta(ktime_get(), before
) > 5000) {
366 pr_err("Timed out waiting for lock bit on pll %s",
375 static void tegra2_pll_clk_init(struct clk
*c
)
377 u32 val
= clk_readl(c
->reg
+ PLL_BASE
);
379 c
->state
= (val
& PLL_BASE_ENABLE
) ? ON
: OFF
;
381 if (c
->flags
& PLL_FIXED
&& !(val
& PLL_BASE_OVERRIDE
)) {
382 pr_warning("Clock %s has unknown fixed frequency\n", c
->name
);
386 } else if (val
& PLL_BASE_BYPASS
) {
391 c
->n
= (val
& PLL_BASE_DIVN_MASK
) >> PLL_BASE_DIVN_SHIFT
;
392 c
->m
= (val
& PLL_BASE_DIVM_MASK
) >> PLL_BASE_DIVM_SHIFT
;
393 c
->p
= (val
& PLL_BASE_DIVP_MASK
) ? 2 : 1;
396 val
= clk_readl(c
->reg
+ PLL_MISC(c
));
397 if (c
->flags
& PLL_HAS_CPCON
)
398 c
->cpcon
= (val
& PLL_MISC_CPCON_MASK
) >> PLL_MISC_CPCON_SHIFT
;
400 tegra2_pll_clk_recalculate_rate(c
);
403 static int tegra2_pll_clk_enable(struct clk
*c
)
406 pr_debug("%s on clock %s\n", __func__
, c
->name
);
408 val
= clk_readl(c
->reg
+ PLL_BASE
);
409 val
&= ~PLL_BASE_BYPASS
;
410 val
|= PLL_BASE_ENABLE
;
411 clk_writel(val
, c
->reg
+ PLL_BASE
);
413 val
= clk_readl(c
->reg
+ PLL_MISC(c
));
414 val
|= PLL_MISC_LOCK_ENABLE
;
415 clk_writel(val
, c
->reg
+ PLL_MISC(c
));
417 tegra2_pll_clk_wait_for_lock(c
);
422 static void tegra2_pll_clk_disable(struct clk
*c
)
425 pr_debug("%s on clock %s\n", __func__
, c
->name
);
427 val
= clk_readl(c
->reg
);
428 val
&= ~(PLL_BASE_BYPASS
| PLL_BASE_ENABLE
);
429 clk_writel(val
, c
->reg
);
432 static int tegra2_pll_clk_set_rate(struct clk
*c
, unsigned long rate
)
435 unsigned long input_rate
;
436 const struct clk_pll_table
*sel
;
438 pr_debug("%s: %s %lu\n", __func__
, c
->name
, rate
);
439 BUG_ON(c
->refcnt
!= 0);
441 input_rate
= c
->parent
->rate
;
442 for (sel
= c
->pll_table
; sel
->input_rate
!= 0; sel
++) {
443 if (sel
->input_rate
== input_rate
&& sel
->output_rate
== rate
) {
447 c
->cpcon
= sel
->cpcon
;
449 val
= clk_readl(c
->reg
+ PLL_BASE
);
450 if (c
->flags
& PLL_FIXED
)
451 val
|= PLL_BASE_OVERRIDE
;
452 val
&= ~(PLL_BASE_DIVP_MASK
| PLL_BASE_DIVN_MASK
|
454 val
|= (c
->m
<< PLL_BASE_DIVM_SHIFT
) |
455 (c
->n
<< PLL_BASE_DIVN_SHIFT
);
458 val
|= 1 << PLL_BASE_DIVP_SHIFT
;
459 clk_writel(val
, c
->reg
+ PLL_BASE
);
461 if (c
->flags
& PLL_HAS_CPCON
) {
462 val
= c
->cpcon
<< PLL_MISC_CPCON_SHIFT
;
463 val
|= PLL_MISC_LOCK_ENABLE
;
464 clk_writel(val
, c
->reg
+ PLL_MISC(c
));
468 tegra2_pll_clk_enable(c
);
477 static struct clk_ops tegra_pll_ops
= {
478 .init
= tegra2_pll_clk_init
,
479 .enable
= tegra2_pll_clk_enable
,
480 .disable
= tegra2_pll_clk_disable
,
481 .set_rate
= tegra2_pll_clk_set_rate
,
482 .recalculate_rate
= tegra2_pll_clk_recalculate_rate
,
485 /* Clock divider ops */
486 static void tegra2_pll_div_clk_init(struct clk
*c
)
488 u32 val
= clk_readl(c
->reg
);
490 val
>>= c
->reg_shift
;
491 c
->state
= (val
& PLL_OUT_CLKEN
) ? ON
: OFF
;
492 if (!(val
& PLL_OUT_RESET_DISABLE
))
495 if (c
->flags
& DIV_U71
) {
496 divu71
= (val
& PLL_OUT_RATIO_MASK
) >> PLL_OUT_RATIO_SHIFT
;
497 c
->div
= (divu71
+ 2);
499 } else if (c
->flags
& DIV_2
) {
507 tegra2_clk_recalculate_rate(c
);
510 static int tegra2_pll_div_clk_enable(struct clk
*c
)
515 pr_debug("%s: %s\n", __func__
, c
->name
);
516 if (c
->flags
& DIV_U71
) {
517 val
= clk_readl(c
->reg
);
518 new_val
= val
>> c
->reg_shift
;
521 new_val
|= PLL_OUT_CLKEN
| PLL_OUT_RESET_DISABLE
;
523 val
&= ~(0xFFFF << c
->reg_shift
);
524 val
|= new_val
<< c
->reg_shift
;
525 clk_writel(val
, c
->reg
);
527 } else if (c
->flags
& DIV_2
) {
528 BUG_ON(!(c
->flags
& PLLD
));
529 val
= clk_readl(c
->reg
);
530 val
&= ~PLLD_MISC_DIV_RST
;
531 clk_writel(val
, c
->reg
);
537 static void tegra2_pll_div_clk_disable(struct clk
*c
)
542 pr_debug("%s: %s\n", __func__
, c
->name
);
543 if (c
->flags
& DIV_U71
) {
544 val
= clk_readl(c
->reg
);
545 new_val
= val
>> c
->reg_shift
;
548 new_val
&= ~(PLL_OUT_CLKEN
| PLL_OUT_RESET_DISABLE
);
550 val
&= ~(0xFFFF << c
->reg_shift
);
551 val
|= new_val
<< c
->reg_shift
;
552 clk_writel(val
, c
->reg
);
553 } else if (c
->flags
& DIV_2
) {
554 BUG_ON(!(c
->flags
& PLLD
));
555 val
= clk_readl(c
->reg
);
556 val
|= PLLD_MISC_DIV_RST
;
557 clk_writel(val
, c
->reg
);
561 static int tegra2_pll_div_clk_set_rate(struct clk
*c
, unsigned long rate
)
566 pr_debug("%s: %s %lu\n", __func__
, c
->name
, rate
);
567 if (c
->flags
& DIV_U71
) {
568 divider_u71
= clk_div71_get_divider(c
->parent
, rate
);
569 if (divider_u71
>= 0) {
570 val
= clk_readl(c
->reg
);
571 new_val
= val
>> c
->reg_shift
;
573 if (c
->flags
& DIV_U71_FIXED
)
574 new_val
|= PLL_OUT_OVERRIDE
;
575 new_val
&= ~PLL_OUT_RATIO_MASK
;
576 new_val
|= divider_u71
<< PLL_OUT_RATIO_SHIFT
;
578 val
&= ~(0xFFFF << c
->reg_shift
);
579 val
|= new_val
<< c
->reg_shift
;
580 clk_writel(val
, c
->reg
);
581 c
->div
= divider_u71
+ 2;
583 tegra2_clk_recalculate_rate(c
);
586 } else if (c
->flags
& DIV_2
) {
587 if (c
->parent
->rate
== rate
* 2) {
596 static struct clk_ops tegra_pll_div_ops
= {
597 .init
= tegra2_pll_div_clk_init
,
598 .enable
= tegra2_pll_div_clk_enable
,
599 .disable
= tegra2_pll_div_clk_disable
,
600 .set_rate
= tegra2_pll_div_clk_set_rate
,
601 .recalculate_rate
= tegra2_clk_recalculate_rate
,
606 static void tegra2_periph_clk_init(struct clk
*c
)
608 u32 val
= clk_readl(c
->reg
);
609 const struct clk_mux_sel
*mux
= 0;
610 const struct clk_mux_sel
*sel
;
611 if (c
->flags
& MUX
) {
612 for (sel
= c
->inputs
; sel
->input
!= NULL
; sel
++) {
613 if (val
>> PERIPH_CLK_SOURCE_SHIFT
== sel
->value
)
618 c
->parent
= mux
->input
;
620 c
->parent
= c
->inputs
[0].input
;
623 if (c
->flags
& DIV_U71
) {
624 u32 divu71
= val
& PERIPH_CLK_SOURCE_DIV_MASK
;
633 if (!(clk_readl(CLK_OUT_ENB
+ PERIPH_CLK_TO_ENB_REG(c
)) &
634 PERIPH_CLK_TO_ENB_BIT(c
)))
636 if (!(c
->flags
& PERIPH_NO_RESET
))
637 if (clk_readl(RST_DEVICES
+ PERIPH_CLK_TO_ENB_REG(c
)) &
638 PERIPH_CLK_TO_ENB_BIT(c
))
640 tegra2_clk_recalculate_rate(c
);
643 static int tegra2_periph_clk_enable(struct clk
*c
)
646 pr_debug("%s on clock %s\n", __func__
, c
->name
);
648 clk_writel(PERIPH_CLK_TO_ENB_BIT(c
),
649 CLK_OUT_ENB_SET
+ PERIPH_CLK_TO_ENB_SET_REG(c
));
650 if (!(c
->flags
& PERIPH_NO_RESET
) && !(c
->flags
& PERIPH_MANUAL_RESET
))
651 clk_writel(PERIPH_CLK_TO_ENB_BIT(c
),
652 RST_DEVICES_CLR
+ PERIPH_CLK_TO_ENB_SET_REG(c
));
653 if (c
->flags
& PERIPH_EMC_ENB
) {
654 /* The EMC peripheral clock has 2 extra enable bits */
655 val
= clk_readl(c
->reg
);
657 clk_writel(val
, c
->reg
);
662 static void tegra2_periph_clk_disable(struct clk
*c
)
664 pr_debug("%s on clock %s\n", __func__
, c
->name
);
666 clk_writel(PERIPH_CLK_TO_ENB_BIT(c
),
667 CLK_OUT_ENB_CLR
+ PERIPH_CLK_TO_ENB_SET_REG(c
));
670 void tegra2_periph_reset_deassert(struct clk
*c
)
672 pr_debug("%s on clock %s\n", __func__
, c
->name
);
673 if (!(c
->flags
& PERIPH_NO_RESET
))
674 clk_writel(PERIPH_CLK_TO_ENB_BIT(c
),
675 RST_DEVICES_CLR
+ PERIPH_CLK_TO_ENB_SET_REG(c
));
678 void tegra2_periph_reset_assert(struct clk
*c
)
680 pr_debug("%s on clock %s\n", __func__
, c
->name
);
681 if (!(c
->flags
& PERIPH_NO_RESET
))
682 clk_writel(PERIPH_CLK_TO_ENB_BIT(c
),
683 RST_DEVICES_SET
+ PERIPH_CLK_TO_ENB_SET_REG(c
));
687 static int tegra2_periph_clk_set_parent(struct clk
*c
, struct clk
*p
)
690 const struct clk_mux_sel
*sel
;
691 pr_debug("%s: %s %s\n", __func__
, c
->name
, p
->name
);
692 for (sel
= c
->inputs
; sel
->input
!= NULL
; sel
++) {
693 if (sel
->input
== p
) {
695 val
= clk_readl(c
->reg
);
696 val
&= ~PERIPH_CLK_SOURCE_MASK
;
697 val
|= (sel
->value
) << PERIPH_CLK_SOURCE_SHIFT
;
698 clk_writel(val
, c
->reg
);
699 c
->rate
= c
->parent
->rate
;
707 static int tegra2_periph_clk_set_rate(struct clk
*c
, unsigned long rate
)
711 pr_debug("%s: %lu\n", __func__
, rate
);
712 if (c
->flags
& DIV_U71
) {
713 divider_u71
= clk_div71_get_divider(c
->parent
, rate
);
714 if (divider_u71
>= 0) {
715 val
= clk_readl(c
->reg
);
716 val
&= ~PERIPH_CLK_SOURCE_DIV_MASK
;
718 clk_writel(val
, c
->reg
);
719 c
->div
= divider_u71
+ 2;
721 tegra2_clk_recalculate_rate(c
);
728 static struct clk_ops tegra_periph_clk_ops
= {
729 .init
= &tegra2_periph_clk_init
,
730 .enable
= &tegra2_periph_clk_enable
,
731 .disable
= &tegra2_periph_clk_disable
,
732 .set_parent
= &tegra2_periph_clk_set_parent
,
733 .set_rate
= &tegra2_periph_clk_set_rate
,
734 .recalculate_rate
= &tegra2_clk_recalculate_rate
,
737 /* Clock doubler ops */
738 static void tegra2_clk_double_init(struct clk
*c
)
743 if (!(clk_readl(CLK_OUT_ENB
+ PERIPH_CLK_TO_ENB_REG(c
)) &
744 PERIPH_CLK_TO_ENB_BIT(c
)))
746 tegra2_clk_recalculate_rate(c
);
749 static struct clk_ops tegra_clk_double_ops
= {
750 .init
= &tegra2_clk_double_init
,
751 .enable
= &tegra2_periph_clk_enable
,
752 .disable
= &tegra2_periph_clk_disable
,
753 .recalculate_rate
= &tegra2_clk_recalculate_rate
,
756 /* Clock definitions */
757 static struct clk tegra_clk_32k
= {
763 static struct clk_pll_table tegra_pll_s_table
[] = {
764 {32768, 12000000, 366, 1, 1, 0},
765 {32768, 13000000, 397, 1, 1, 0},
766 {32768, 19200000, 586, 1, 1, 0},
767 {32768, 26000000, 793, 1, 1, 0},
771 static struct clk tegra_pll_s
= {
773 .flags
= PLL_ALT_MISC_REG
,
774 .ops
= &tegra_pll_ops
,
778 .parent
= &tegra_clk_32k
,
783 .pll_table
= tegra_pll_s_table
,
786 static struct clk_mux_sel tegra_clk_m_sel
[] = {
787 { .input
= &tegra_clk_32k
, .value
= 0},
788 { .input
= &tegra_pll_s
, .value
= 1},
791 static struct clk tegra_clk_m
= {
793 .flags
= ENABLE_ON_INIT
,
794 .ops
= &tegra_clk_m_ops
,
795 .inputs
= tegra_clk_m_sel
,
801 static struct clk_pll_table tegra_pll_c_table
[] = {
802 { 0, 0, 0, 0, 0, 0 },
805 static struct clk tegra_pll_c
= {
807 .flags
= PLL_HAS_CPCON
,
808 .ops
= &tegra_pll_ops
,
810 .input_min
= 2000000,
811 .input_max
= 31000000,
812 .parent
= &tegra_clk_m
,
816 .vco_max
= 1400000000,
817 .pll_table
= tegra_pll_c_table
,
820 static struct clk tegra_pll_c_out1
= {
821 .name
= "pll_c_out1",
822 .ops
= &tegra_pll_div_ops
,
824 .parent
= &tegra_pll_c
,
829 static struct clk_pll_table tegra_pll_m_table
[] = {
830 { 0, 0, 0, 0, 0, 0 },
833 static struct clk tegra_pll_m
= {
835 .flags
= PLL_HAS_CPCON
,
836 .ops
= &tegra_pll_ops
,
838 .input_min
= 2000000,
839 .input_max
= 31000000,
840 .parent
= &tegra_clk_m
,
844 .vco_max
= 1200000000,
845 .pll_table
= tegra_pll_m_table
,
848 static struct clk tegra_pll_m_out1
= {
849 .name
= "pll_m_out1",
850 .ops
= &tegra_pll_div_ops
,
852 .parent
= &tegra_pll_m
,
857 static struct clk_pll_table tegra_pll_p_table
[] = {
858 { 12000000, 216000000, 432, 12, 2, 8},
859 { 13000000, 216000000, 432, 13, 2, 8},
860 { 19200000, 216000000, 90, 4, 2, 1},
861 { 26000000, 216000000, 432, 26, 2, 8},
862 { 12000000, 432000000, 432, 12, 1, 8},
863 { 13000000, 432000000, 432, 13, 1, 8},
864 { 19200000, 432000000, 90, 4, 1, 1},
865 { 26000000, 432000000, 432, 26, 1, 8},
866 { 0, 0, 0, 0, 0, 0 },
869 static struct clk tegra_pll_p
= {
871 .flags
= ENABLE_ON_INIT
| PLL_FIXED
| PLL_HAS_CPCON
,
872 .ops
= &tegra_pll_ops
,
874 .input_min
= 2000000,
875 .input_max
= 31000000,
876 .parent
= &tegra_clk_m
,
880 .vco_max
= 1400000000,
881 .pll_table
= tegra_pll_p_table
,
884 static struct clk tegra_pll_p_out1
= {
885 .name
= "pll_p_out1",
886 .ops
= &tegra_pll_div_ops
,
887 .flags
= ENABLE_ON_INIT
| DIV_U71
| DIV_U71_FIXED
,
888 .parent
= &tegra_pll_p
,
893 static struct clk tegra_pll_p_out2
= {
894 .name
= "pll_p_out2",
895 .ops
= &tegra_pll_div_ops
,
896 .flags
= ENABLE_ON_INIT
| DIV_U71
| DIV_U71_FIXED
,
897 .parent
= &tegra_pll_p
,
902 static struct clk tegra_pll_p_out3
= {
903 .name
= "pll_p_out3",
904 .ops
= &tegra_pll_div_ops
,
905 .flags
= ENABLE_ON_INIT
| DIV_U71
| DIV_U71_FIXED
,
906 .parent
= &tegra_pll_p
,
911 static struct clk tegra_pll_p_out4
= {
912 .name
= "pll_p_out4",
913 .ops
= &tegra_pll_div_ops
,
914 .flags
= ENABLE_ON_INIT
| DIV_U71
| DIV_U71_FIXED
,
915 .parent
= &tegra_pll_p
,
920 static struct clk_pll_table tegra_pll_a_table
[] = {
921 { 28800000, 56448000, 49, 25, 1, 1},
922 { 28800000, 73728000, 64, 25, 1, 1},
923 { 28800000, 11289600, 49, 25, 1, 1},
924 { 28800000, 12288000, 64, 25, 1, 1},
925 { 0, 0, 0, 0, 0, 0 },
928 static struct clk tegra_pll_a
= {
930 .flags
= PLL_HAS_CPCON
,
931 .ops
= &tegra_pll_ops
,
933 .input_min
= 2000000,
934 .input_max
= 31000000,
935 .parent
= &tegra_pll_p_out1
,
939 .vco_max
= 1400000000,
940 .pll_table
= tegra_pll_a_table
,
943 static struct clk tegra_pll_a_out0
= {
944 .name
= "pll_a_out0",
945 .ops
= &tegra_pll_div_ops
,
947 .parent
= &tegra_pll_a
,
952 static struct clk_pll_table tegra_pll_d_table
[] = {
953 { 12000000, 1000000000, 1000, 12, 1, 12},
954 { 13000000, 1000000000, 1000, 13, 1, 12},
955 { 19200000, 1000000000, 625, 12, 1, 8},
956 { 26000000, 1000000000, 1000, 26, 1, 12},
957 { 0, 0, 0, 0, 0, 0 },
960 static struct clk tegra_pll_d
= {
962 .flags
= PLL_HAS_CPCON
| PLLD
,
963 .ops
= &tegra_pll_ops
,
965 .input_min
= 2000000,
966 .input_max
= 40000000,
967 .parent
= &tegra_clk_m
,
971 .vco_max
= 1000000000,
972 .pll_table
= tegra_pll_d_table
,
975 static struct clk tegra_pll_d_out0
= {
976 .name
= "pll_d_out0",
977 .ops
= &tegra_pll_div_ops
,
978 .flags
= DIV_2
| PLLD
,
979 .parent
= &tegra_pll_d
,
982 static struct clk_pll_table tegra_pll_u_table
[] = {
983 { 12000000, 480000000, 960, 12, 1, 0},
984 { 13000000, 480000000, 960, 13, 1, 0},
985 { 19200000, 480000000, 200, 4, 1, 0},
986 { 26000000, 480000000, 960, 26, 1, 0},
987 { 0, 0, 0, 0, 0, 0 },
990 static struct clk tegra_pll_u
= {
993 .ops
= &tegra_pll_ops
,
995 .input_min
= 2000000,
996 .input_max
= 40000000,
997 .parent
= &tegra_clk_m
,
1000 .vco_min
= 480000000,
1001 .vco_max
= 960000000,
1002 .pll_table
= tegra_pll_u_table
,
1005 static struct clk_pll_table tegra_pll_x_table
[] = {
1006 { 12000000, 1000000000, 1000, 12, 1, 12},
1007 { 13000000, 1000000000, 1000, 13, 1, 12},
1008 { 19200000, 1000000000, 625, 12, 1, 8},
1009 { 26000000, 1000000000, 1000, 26, 1, 12},
1010 { 12000000, 750000000, 750, 12, 1, 12},
1011 { 13000000, 750000000, 750, 13, 1, 12},
1012 { 19200000, 750000000, 625, 16, 1, 8},
1013 { 26000000, 750000000, 750, 26, 1, 12},
1014 { 0, 0, 0, 0, 0, 0 },
1017 static struct clk tegra_pll_x
= {
1019 .flags
= PLL_HAS_CPCON
| PLL_ALT_MISC_REG
,
1020 .ops
= &tegra_pll_ops
,
1022 .input_min
= 2000000,
1023 .input_max
= 31000000,
1024 .parent
= &tegra_clk_m
,
1027 .vco_min
= 20000000,
1028 .vco_max
= 1200000000,
1029 .pll_table
= tegra_pll_x_table
,
1032 static struct clk tegra_clk_d
= {
1034 .flags
= PERIPH_NO_RESET
,
1035 .ops
= &tegra_clk_double_ops
,
1039 .parent
= &tegra_clk_m
,
1043 static struct clk_mux_sel mux_cclk
[] = {
1044 { .input
= &tegra_clk_m
, .value
= 0},
1045 { .input
= &tegra_pll_c
, .value
= 1},
1046 { .input
= &tegra_clk_32k
, .value
= 2},
1047 { .input
= &tegra_pll_m
, .value
= 3},
1048 { .input
= &tegra_pll_p
, .value
= 4},
1049 { .input
= &tegra_pll_p_out4
, .value
= 5},
1050 { .input
= &tegra_pll_p_out3
, .value
= 6},
1051 { .input
= &tegra_clk_d
, .value
= 7},
1052 { .input
= &tegra_pll_x
, .value
= 8},
1056 static struct clk_mux_sel mux_sclk
[] = {
1057 { .input
= &tegra_clk_m
, .value
= 0},
1058 { .input
= &tegra_pll_c_out1
, .value
= 1},
1059 { .input
= &tegra_pll_p_out4
, .value
= 2},
1060 { .input
= &tegra_pll_p_out3
, .value
= 3},
1061 { .input
= &tegra_pll_p_out2
, .value
= 4},
1062 { .input
= &tegra_clk_d
, .value
= 5},
1063 { .input
= &tegra_clk_32k
, .value
= 6},
1064 { .input
= &tegra_pll_m_out1
, .value
= 7},
1068 static struct clk tegra_clk_cpu
= {
1072 .ops
= &tegra_super_ops
,
1075 static struct clk tegra_clk_sys
= {
1079 .ops
= &tegra_super_ops
,
1082 static struct clk tegra_clk_hclk
= {
1085 .parent
= &tegra_clk_sys
,
1088 .ops
= &tegra_bus_ops
,
1091 static struct clk tegra_clk_pclk
= {
1094 .parent
= &tegra_clk_hclk
,
1097 .ops
= &tegra_bus_ops
,
1100 static struct clk_mux_sel mux_pllm_pllc_pllp_plla
[] = {
1101 { .input
= &tegra_pll_m
, .value
= 0},
1102 { .input
= &tegra_pll_c
, .value
= 1},
1103 { .input
= &tegra_pll_p
, .value
= 2},
1104 { .input
= &tegra_pll_a_out0
, .value
= 3},
1108 static struct clk_mux_sel mux_pllm_pllc_pllp_clkm
[] = {
1109 { .input
= &tegra_pll_m
, .value
= 0},
1110 { .input
= &tegra_pll_c
, .value
= 1},
1111 { .input
= &tegra_pll_p
, .value
= 2},
1112 { .input
= &tegra_clk_m
, .value
= 3},
1116 static struct clk_mux_sel mux_pllp_pllc_pllm_clkm
[] = {
1117 { .input
= &tegra_pll_p
, .value
= 0},
1118 { .input
= &tegra_pll_c
, .value
= 1},
1119 { .input
= &tegra_pll_m
, .value
= 2},
1120 { .input
= &tegra_clk_m
, .value
= 3},
1124 static struct clk_mux_sel mux_plla_audio_pllp_clkm
[] = {
1125 {.input
= &tegra_pll_a
, .value
= 0},
1126 {.input
= &tegra_pll_p
, .value
= 2},
1127 {.input
= &tegra_clk_m
, .value
= 3},
1131 static struct clk_mux_sel mux_pllp_plld_pllc_clkm
[] = {
1132 {.input
= &tegra_pll_p
, .value
= 0},
1133 {.input
= &tegra_pll_d_out0
, .value
= 1},
1134 {.input
= &tegra_pll_c
, .value
= 2},
1135 {.input
= &tegra_clk_m
, .value
= 3},
1139 static struct clk_mux_sel mux_pllp_pllc_audio_clkm_clk32
[] = {
1140 {.input
= &tegra_pll_p
, .value
= 0},
1141 {.input
= &tegra_pll_c
, .value
= 1},
1142 {.input
= &tegra_clk_m
, .value
= 3},
1143 {.input
= &tegra_clk_32k
, .value
= 4},
1147 static struct clk_mux_sel mux_pllp_pllc_pllm
[] = {
1148 {.input
= &tegra_pll_p
, .value
= 0},
1149 {.input
= &tegra_pll_c
, .value
= 1},
1150 {.input
= &tegra_pll_m
, .value
= 2},
1154 static struct clk_mux_sel mux_clk_m
[] = {
1155 { .input
= &tegra_clk_m
, .value
= 0},
1159 static struct clk_mux_sel mux_pllp_out3
[] = {
1160 { .input
= &tegra_pll_p_out3
, .value
= 0},
1164 static struct clk_mux_sel mux_plld
[] = {
1165 { .input
= &tegra_pll_d
, .value
= 0},
1169 static struct clk_mux_sel mux_clk_32k
[] = {
1170 { .input
= &tegra_clk_32k
, .value
= 0},
1174 #define PERIPH_CLK(_name, _dev, _con, _clk_num, _reg, _inputs, _flags) \
1181 .ops = &tegra_periph_clk_ops, \
1182 .clk_num = _clk_num, \
1184 .inputs = _inputs, \
1188 struct clk tegra_periph_clks
[] = {
1189 PERIPH_CLK("rtc", "rtc-tegra", NULL
, 4, 0, mux_clk_32k
, PERIPH_NO_RESET
),
1190 PERIPH_CLK("timer", "timer", NULL
, 5, 0, mux_clk_m
, 0),
1191 PERIPH_CLK("i2s1", "i2s.0", NULL
, 11, 0x100, mux_plla_audio_pllp_clkm
, MUX
| DIV_U71
),
1192 PERIPH_CLK("i2s2", "i2s.1", NULL
, 18, 0x104, mux_plla_audio_pllp_clkm
, MUX
| DIV_U71
),
1193 PERIPH_CLK("spdif_out", "spdif_out", NULL
, 10, 0x108, mux_plla_audio_pllp_clkm
, MUX
| DIV_U71
),
1194 PERIPH_CLK("spdif_in", "spdif_in", NULL
, 10, 0x10c, mux_pllp_pllc_pllm
, MUX
| DIV_U71
),
1195 PERIPH_CLK("pwm", "pwm", NULL
, 17, 0x110, mux_pllp_pllc_audio_clkm_clk32
, MUX
| DIV_U71
),
1196 PERIPH_CLK("spi", "spi", NULL
, 43, 0x114, mux_pllp_pllc_pllm_clkm
, MUX
| DIV_U71
),
1197 PERIPH_CLK("xio", "xio", NULL
, 45, 0x120, mux_pllp_pllc_pllm_clkm
, MUX
| DIV_U71
),
1198 PERIPH_CLK("twc", "twc", NULL
, 16, 0x12c, mux_pllp_pllc_pllm_clkm
, MUX
| DIV_U71
),
1199 PERIPH_CLK("sbc1", "spi_tegra.0", NULL
, 41, 0x134, mux_pllp_pllc_pllm_clkm
, MUX
| DIV_U71
),
1200 PERIPH_CLK("sbc2", "spi_tegra.1", NULL
, 44, 0x118, mux_pllp_pllc_pllm_clkm
, MUX
| DIV_U71
),
1201 PERIPH_CLK("sbc3", "spi_tegra.2", NULL
, 46, 0x11c, mux_pllp_pllc_pllm_clkm
, MUX
| DIV_U71
),
1202 PERIPH_CLK("sbc4", "spi_tegra.3", NULL
, 68, 0x1b4, mux_pllp_pllc_pllm_clkm
, MUX
| DIV_U71
),
1203 PERIPH_CLK("ide", "ide", NULL
, 25, 0x144, mux_pllp_pllc_pllm_clkm
, MUX
| DIV_U71
),
1204 PERIPH_CLK("ndflash", "tegra_nand", NULL
, 13, 0x160, mux_pllp_pllc_pllm_clkm
, MUX
| DIV_U71
),
1205 PERIPH_CLK("vfir", "vfir", NULL
, 7, 0x168, mux_pllp_pllc_pllm_clkm
, MUX
| DIV_U71
),
1206 PERIPH_CLK("sdmmc1", "sdhci-tegra.0", NULL
, 14, 0x150, mux_pllp_pllc_pllm_clkm
, MUX
| DIV_U71
),
1207 PERIPH_CLK("sdmmc2", "sdhci-tegra.1", NULL
, 9, 0x154, mux_pllp_pllc_pllm_clkm
, MUX
| DIV_U71
),
1208 PERIPH_CLK("sdmmc3", "sdhci-tegra.2", NULL
, 69, 0x1bc, mux_pllp_pllc_pllm_clkm
, MUX
| DIV_U71
),
1209 PERIPH_CLK("sdmmc4", "sdhci-tegra.3", NULL
, 15, 0x160, mux_pllp_pllc_pllm_clkm
, MUX
| DIV_U71
),
1210 PERIPH_CLK("vde", "vde", NULL
, 61, 0x1c8, mux_pllp_pllc_pllm_clkm
, MUX
| DIV_U71
),
1211 PERIPH_CLK("csite", "csite", NULL
, 73, 0x1d4, mux_pllp_pllc_pllm_clkm
, MUX
| DIV_U71
),
1212 PERIPH_CLK("la", "la", NULL
, 76, 0x1f8, mux_pllp_pllc_pllm_clkm
, MUX
| DIV_U71
),
1213 PERIPH_CLK("owr", "owr", NULL
, 71, 0x1cc, mux_pllp_pllc_pllm_clkm
, MUX
| DIV_U71
),
1214 PERIPH_CLK("nor", "nor", NULL
, 42, 0x1d0, mux_pllp_pllc_pllm_clkm
, MUX
| DIV_U71
),
1215 PERIPH_CLK("mipi", "mipi", NULL
, 50, 0x174, mux_pllp_pllc_pllm_clkm
, MUX
| DIV_U71
),
1216 PERIPH_CLK("i2c1", "tegra-i2c.0", NULL
, 12, 0x124, mux_pllp_pllc_pllm_clkm
, MUX
| DIV_U71
),
1217 PERIPH_CLK("i2c2", "tegra-i2c.1", NULL
, 54, 0x198, mux_pllp_pllc_pllm_clkm
, MUX
| DIV_U71
),
1218 PERIPH_CLK("i2c3", "tegra-i2c.2", NULL
, 67, 0x1b8, mux_pllp_pllc_pllm_clkm
, MUX
| DIV_U71
),
1219 PERIPH_CLK("dvc", "tegra-i2c.3", NULL
, 47, 0x128, mux_pllp_pllc_pllm_clkm
, MUX
| DIV_U71
),
1220 PERIPH_CLK("i2c1_i2c", "tegra-i2c.0", "i2c", 0, 0, mux_pllp_out3
, 0),
1221 PERIPH_CLK("i2c2_i2c", "tegra-i2c.1", "i2c", 0, 0, mux_pllp_out3
, 0),
1222 PERIPH_CLK("i2c3_i2c", "tegra-i2c.2", "i2c", 0, 0, mux_pllp_out3
, 0),
1223 PERIPH_CLK("dvc_i2c", "tegra-i2c.3", "i2c", 0, 0, mux_pllp_out3
, 0),
1224 PERIPH_CLK("uarta", "uart.0", NULL
, 6, 0x178, mux_pllp_pllc_pllm_clkm
, MUX
| DIV_U71
),
1225 PERIPH_CLK("uartb", "uart.1", NULL
, 7, 0x17c, mux_pllp_pllc_pllm_clkm
, MUX
| DIV_U71
),
1226 PERIPH_CLK("uartc", "uart.2", NULL
, 55, 0x1a0, mux_pllp_pllc_pllm_clkm
, MUX
| DIV_U71
),
1227 PERIPH_CLK("uartd", "uart.3", NULL
, 65, 0x1c0, mux_pllp_pllc_pllm_clkm
, MUX
| DIV_U71
),
1228 PERIPH_CLK("uarte", "uart.4", NULL
, 66, 0x1c4, mux_pllp_pllc_pllm_clkm
, MUX
| DIV_U71
),
1229 PERIPH_CLK("3d", "3d", NULL
, 24, 0x158, mux_pllm_pllc_pllp_plla
, MUX
| DIV_U71
| PERIPH_MANUAL_RESET
),
1230 PERIPH_CLK("2d", "2d", NULL
, 21, 0x15c, mux_pllm_pllc_pllp_plla
, MUX
| DIV_U71
),
1231 PERIPH_CLK("vi", "vi", NULL
, 20, 0x148, mux_pllm_pllc_pllp_plla
, MUX
| DIV_U71
),
1232 PERIPH_CLK("vi_sensor", "vi_sensor", NULL
, 20, 0x1a8, mux_pllm_pllc_pllp_plla
, MUX
| DIV_U71
),
1233 PERIPH_CLK("epp", "epp", NULL
, 19, 0x16c, mux_pllm_pllc_pllp_plla
, MUX
| DIV_U71
),
1234 PERIPH_CLK("mpe", "mpe", NULL
, 60, 0x170, mux_pllm_pllc_pllp_plla
, MUX
| DIV_U71
),
1235 PERIPH_CLK("host1x", "host1x", NULL
, 28, 0x180, mux_pllm_pllc_pllp_plla
, MUX
| DIV_U71
),
1236 PERIPH_CLK("cve", "cve", NULL
, 49, 0x140, mux_pllp_plld_pllc_clkm
, MUX
| DIV_U71
),
1237 PERIPH_CLK("tvo", "tvo", NULL
, 49, 0x188, mux_pllp_plld_pllc_clkm
, MUX
| DIV_U71
),
1238 PERIPH_CLK("hdmi", "hdmi", NULL
, 51, 0x18c, mux_pllp_plld_pllc_clkm
, MUX
| DIV_U71
),
1239 PERIPH_CLK("tvdac", "tvdac", NULL
, 53, 0x194, mux_pllp_plld_pllc_clkm
, MUX
| DIV_U71
),
1240 PERIPH_CLK("disp1", "tegrafb.0", NULL
, 27, 0x138, mux_pllp_plld_pllc_clkm
, MUX
| DIV_U71
),
1241 PERIPH_CLK("disp2", "tegrafb.1", NULL
, 26, 0x13c, mux_pllp_plld_pllc_clkm
, MUX
| DIV_U71
),
1242 PERIPH_CLK("usbd", "fsl-tegra-udc", NULL
, 22, 0, mux_clk_m
, 0),
1243 PERIPH_CLK("usb2", "usb.1", NULL
, 58, 0, mux_clk_m
, 0),
1244 PERIPH_CLK("usb3", "usb.2", NULL
, 59, 0, mux_clk_m
, 0),
1245 PERIPH_CLK("emc", "emc", NULL
, 57, 0x19c, mux_pllm_pllc_pllp_clkm
, MUX
| DIV_U71
| PERIPH_EMC_ENB
),
1246 PERIPH_CLK("dsi", "dsi", NULL
, 48, 0, mux_plld
, 0),
1249 #define CLK_DUPLICATE(_name, _dev, _con) \
1258 /* Some clocks may be used by different drivers depending on the board
1259 * configuration. List those here to register them twice in the clock lookup
1260 * table under two names.
1262 struct clk_duplicate tegra_clk_duplicates
[] = {
1263 CLK_DUPLICATE("uarta", "tegra_uart.0", NULL
),
1264 CLK_DUPLICATE("uartb", "tegra_uart.1", NULL
),
1265 CLK_DUPLICATE("uartc", "tegra_uart.2", NULL
),
1266 CLK_DUPLICATE("uartd", "tegra_uart.3", NULL
),
1267 CLK_DUPLICATE("uarte", "tegra_uart.4", NULL
),
1270 #define CLK(dev, con, ck) \
1277 struct clk_lookup tegra_clk_lookups
[] = {
1278 /* external root sources */
1279 CLK(NULL
, "32k_clk", &tegra_clk_32k
),
1280 CLK(NULL
, "pll_s", &tegra_pll_s
),
1281 CLK(NULL
, "clk_m", &tegra_clk_m
),
1282 CLK(NULL
, "pll_m", &tegra_pll_m
),
1283 CLK(NULL
, "pll_m_out1", &tegra_pll_m_out1
),
1284 CLK(NULL
, "pll_c", &tegra_pll_c
),
1285 CLK(NULL
, "pll_c_out1", &tegra_pll_c_out1
),
1286 CLK(NULL
, "pll_p", &tegra_pll_p
),
1287 CLK(NULL
, "pll_p_out1", &tegra_pll_p_out1
),
1288 CLK(NULL
, "pll_p_out2", &tegra_pll_p_out2
),
1289 CLK(NULL
, "pll_p_out3", &tegra_pll_p_out3
),
1290 CLK(NULL
, "pll_p_out4", &tegra_pll_p_out4
),
1291 CLK(NULL
, "pll_a", &tegra_pll_a
),
1292 CLK(NULL
, "pll_a_out0", &tegra_pll_a_out0
),
1293 CLK(NULL
, "pll_d", &tegra_pll_d
),
1294 CLK(NULL
, "pll_d_out0", &tegra_pll_d_out0
),
1295 CLK(NULL
, "pll_u", &tegra_pll_u
),
1296 CLK(NULL
, "pll_x", &tegra_pll_x
),
1297 CLK(NULL
, "cpu", &tegra_clk_cpu
),
1298 CLK(NULL
, "sys", &tegra_clk_sys
),
1299 CLK(NULL
, "hclk", &tegra_clk_hclk
),
1300 CLK(NULL
, "pclk", &tegra_clk_pclk
),
1301 CLK(NULL
, "clk_d", &tegra_clk_d
),
1304 void __init
tegra2_init_clocks(void)
1307 struct clk_lookup
*cl
;
1309 struct clk_duplicate
*cd
;
1311 for (i
= 0; i
< ARRAY_SIZE(tegra_clk_lookups
); i
++) {
1312 cl
= &tegra_clk_lookups
[i
];
1317 for (i
= 0; i
< ARRAY_SIZE(tegra_periph_clks
); i
++) {
1318 c
= &tegra_periph_clks
[i
];
1326 for (i
= 0; i
< ARRAY_SIZE(tegra_clk_duplicates
); i
++) {
1327 cd
= &tegra_clk_duplicates
[i
];
1328 c
= tegra_get_clock_by_name(cd
->name
);
1334 pr_err("%s: Unknown duplicate clock %s\n", __func__
,