?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'v6v7' into devel
[linux/fpc-iii.git] / arch / arm / mach-tegra / tegra2_clocks.c
blobf0dae6d8ba520a5046848dc7710caa92624a4f0d
1 /*
2 * arch/arm/mach-tegra/tegra2_clocks.c
3 *
4 * Copyright (C) 2010 Google, Inc.
5 *
6 * Author:
7 * Colin Cross <ccross@google.com>
8 *
9 * 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.
12 *
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.
17 *
18 */
19
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>
25 #include <linux/io.h>
26 #include <linux/hrtimer.h>
27 #include <linux/clkdev.h>
28
29 #include <mach/iomap.h>
30
31 #include "clock.h"
32 #include "fuse.h"
33 #include "tegra2_dvfs.h"
34
35 #define RST_DEVICES 0x004
36 #define RST_DEVICES_SET 0x300
37 #define RST_DEVICES_CLR 0x304
38 #define RST_DEVICES_NUM 3
39
40 #define CLK_OUT_ENB 0x010
41 #define CLK_OUT_ENB_SET 0x320
42 #define CLK_OUT_ENB_CLR 0x324
43 #define CLK_OUT_ENB_NUM 3
44
45 #define CLK_MASK_ARM 0x44
46 #define MISC_CLK_ENB 0x48
47
48 #define OSC_CTRL 0x50
49 #define OSC_CTRL_OSC_FREQ_MASK (3<<30)
50 #define OSC_CTRL_OSC_FREQ_13MHZ (0<<30)
51 #define OSC_CTRL_OSC_FREQ_19_2MHZ (1<<30)
52 #define OSC_CTRL_OSC_FREQ_12MHZ (2<<30)
53 #define OSC_CTRL_OSC_FREQ_26MHZ (3<<30)
54 #define OSC_CTRL_MASK 0x3f2
55
56 #define OSC_FREQ_DET 0x58
57 #define OSC_FREQ_DET_TRIG (1<<31)
58
59 #define OSC_FREQ_DET_STATUS 0x5C
60 #define OSC_FREQ_DET_BUSY (1<<31)
61 #define OSC_FREQ_DET_CNT_MASK 0xFFFF
62
63 #define PERIPH_CLK_SOURCE_I2S1 0x100
64 #define PERIPH_CLK_SOURCE_EMC 0x19c
65 #define PERIPH_CLK_SOURCE_OSC 0x1fc
66 #define PERIPH_CLK_SOURCE_NUM \
67 ((PERIPH_CLK_SOURCE_OSC - PERIPH_CLK_SOURCE_I2S1) / 4)
68
69 #define PERIPH_CLK_SOURCE_MASK (3<<30)
70 #define PERIPH_CLK_SOURCE_SHIFT 30
71 #define PERIPH_CLK_SOURCE_ENABLE (1<<28)
72 #define PERIPH_CLK_SOURCE_DIVU71_MASK 0xFF
73 #define PERIPH_CLK_SOURCE_DIVU16_MASK 0xFFFF
74 #define PERIPH_CLK_SOURCE_DIV_SHIFT 0
75
76 #define PLL_BASE 0x0
77 #define PLL_BASE_BYPASS (1<<31)
78 #define PLL_BASE_ENABLE (1<<30)
79 #define PLL_BASE_REF_ENABLE (1<<29)
80 #define PLL_BASE_OVERRIDE (1<<28)
81 #define PLL_BASE_LOCK (1<<27)
82 #define PLL_BASE_DIVP_MASK (0x7<<20)
83 #define PLL_BASE_DIVP_SHIFT 20
84 #define PLL_BASE_DIVN_MASK (0x3FF<<8)
85 #define PLL_BASE_DIVN_SHIFT 8
86 #define PLL_BASE_DIVM_MASK (0x1F)
87 #define PLL_BASE_DIVM_SHIFT 0
88
89 #define PLL_OUT_RATIO_MASK (0xFF<<8)
90 #define PLL_OUT_RATIO_SHIFT 8
91 #define PLL_OUT_OVERRIDE (1<<2)
92 #define PLL_OUT_CLKEN (1<<1)
93 #define PLL_OUT_RESET_DISABLE (1<<0)
94
95 #define PLL_MISC(c) (((c)->flags & PLL_ALT_MISC_REG) ? 0x4 : 0xc)
96 #define PLL_MISC_LOCK_ENABLE(c) (((c)->flags & PLLU) ? (1<<22) : (1<<18))
97
98 #define PLL_MISC_DCCON_SHIFT 20
99 #define PLL_MISC_CPCON_SHIFT 8
100 #define PLL_MISC_CPCON_MASK (0xF<<PLL_MISC_CPCON_SHIFT)
101 #define PLL_MISC_LFCON_SHIFT 4
102 #define PLL_MISC_LFCON_MASK (0xF<<PLL_MISC_LFCON_SHIFT)
103 #define PLL_MISC_VCOCON_SHIFT 0
104 #define PLL_MISC_VCOCON_MASK (0xF<<PLL_MISC_VCOCON_SHIFT)
105
106 #define PLLU_BASE_POST_DIV (1<<20)
107
108 #define PLLD_MISC_CLKENABLE (1<<30)
109 #define PLLD_MISC_DIV_RST (1<<23)
110 #define PLLD_MISC_DCCON_SHIFT 12
111
112 #define PLLE_MISC_READY (1 << 15)
113
114 #define PERIPH_CLK_TO_ENB_REG(c) ((c->clk_num / 32) * 4)
115 #define PERIPH_CLK_TO_ENB_SET_REG(c) ((c->clk_num / 32) * 8)
116 #define PERIPH_CLK_TO_ENB_BIT(c) (1 << (c->clk_num % 32))
117
118 #define SUPER_CLK_MUX 0x00
119 #define SUPER_STATE_SHIFT 28
120 #define SUPER_STATE_MASK (0xF << SUPER_STATE_SHIFT)
121 #define SUPER_STATE_STANDBY (0x0 << SUPER_STATE_SHIFT)
122 #define SUPER_STATE_IDLE (0x1 << SUPER_STATE_SHIFT)
123 #define SUPER_STATE_RUN (0x2 << SUPER_STATE_SHIFT)
124 #define SUPER_STATE_IRQ (0x3 << SUPER_STATE_SHIFT)
125 #define SUPER_STATE_FIQ (0x4 << SUPER_STATE_SHIFT)
126 #define SUPER_SOURCE_MASK 0xF
127 #define SUPER_FIQ_SOURCE_SHIFT 12
128 #define SUPER_IRQ_SOURCE_SHIFT 8
129 #define SUPER_RUN_SOURCE_SHIFT 4
130 #define SUPER_IDLE_SOURCE_SHIFT 0
131
132 #define SUPER_CLK_DIVIDER 0x04
133
134 #define BUS_CLK_DISABLE (1<<3)
135 #define BUS_CLK_DIV_MASK 0x3
136
137 static void __iomem *reg_clk_base = IO_ADDRESS(TEGRA_CLK_RESET_BASE);
138
139 #define clk_writel(value, reg) \
140 __raw_writel(value, (u32)reg_clk_base + (reg))
141 #define clk_readl(reg) \
142 __raw_readl((u32)reg_clk_base + (reg))
143
144 unsigned long clk_measure_input_freq(void)
145 {
146 u32 clock_autodetect;
147 clk_writel(OSC_FREQ_DET_TRIG | 1, OSC_FREQ_DET);
148 do {} while (clk_readl(OSC_FREQ_DET_STATUS) & OSC_FREQ_DET_BUSY);
149 clock_autodetect = clk_readl(OSC_FREQ_DET_STATUS);
150 if (clock_autodetect >= 732 - 3 && clock_autodetect <= 732 + 3) {
151 return 12000000;
152 } else if (clock_autodetect >= 794 - 3 && clock_autodetect <= 794 + 3) {
153 return 13000000;
154 } else if (clock_autodetect >= 1172 - 3 && clock_autodetect <= 1172 + 3) {
155 return 19200000;
156 } else if (clock_autodetect >= 1587 - 3 && clock_autodetect <= 1587 + 3) {
157 return 26000000;
158 } else {
159 pr_err("%s: Unexpected clock autodetect value %d", __func__, clock_autodetect);
160 BUG();
161 return 0;
162 }
163 }
164
165 static int clk_div71_get_divider(unsigned long parent_rate, unsigned long rate)
166 {
167 s64 divider_u71 = parent_rate * 2;
168 divider_u71 += rate - 1;
169 do_div(divider_u71, rate);
170
171 if (divider_u71 - 2 < 0)
172 return 0;
173
174 if (divider_u71 - 2 > 255)
175 return -EINVAL;
176
177 return divider_u71 - 2;
178 }
179
180 static int clk_div16_get_divider(unsigned long parent_rate, unsigned long rate)
181 {
182 s64 divider_u16;
183
184 divider_u16 = parent_rate;
185 divider_u16 += rate - 1;
186 do_div(divider_u16, rate);
187
188 if (divider_u16 - 1 < 0)
189 return 0;
190
191 if (divider_u16 - 1 > 255)
192 return -EINVAL;
193
194 return divider_u16 - 1;
195 }
196
197 /* clk_m functions */
198 static unsigned long tegra2_clk_m_autodetect_rate(struct clk *c)
199 {
200 u32 auto_clock_control = clk_readl(OSC_CTRL) & ~OSC_CTRL_OSC_FREQ_MASK;
201
202 c->rate = clk_measure_input_freq();
203 switch (c->rate) {
204 case 12000000:
205 auto_clock_control |= OSC_CTRL_OSC_FREQ_12MHZ;
206 break;
207 case 13000000:
208 auto_clock_control |= OSC_CTRL_OSC_FREQ_13MHZ;
209 break;
210 case 19200000:
211 auto_clock_control |= OSC_CTRL_OSC_FREQ_19_2MHZ;
212 break;
213 case 26000000:
214 auto_clock_control |= OSC_CTRL_OSC_FREQ_26MHZ;
215 break;
216 default:
217 pr_err("%s: Unexpected clock rate %ld", __func__, c->rate);
218 BUG();
219 }
220 clk_writel(auto_clock_control, OSC_CTRL);
221 return c->rate;
222 }
223
224 static void tegra2_clk_m_init(struct clk *c)
225 {
226 pr_debug("%s on clock %s\n", __func__, c->name);
227 tegra2_clk_m_autodetect_rate(c);
228 }
229
230 static int tegra2_clk_m_enable(struct clk *c)
231 {
232 pr_debug("%s on clock %s\n", __func__, c->name);
233 return 0;
234 }
235
236 static void tegra2_clk_m_disable(struct clk *c)
237 {
238 pr_debug("%s on clock %s\n", __func__, c->name);
239 BUG();
240 }
241
242 static struct clk_ops tegra_clk_m_ops = {
243 .init = tegra2_clk_m_init,
244 .enable = tegra2_clk_m_enable,
245 .disable = tegra2_clk_m_disable,
246 };
247
248 /* super clock functions */
249 /* "super clocks" on tegra have two-stage muxes and a clock skipping
250 * super divider. We will ignore the clock skipping divider, since we
251 * can't lower the voltage when using the clock skip, but we can if we
252 * lower the PLL frequency.
253 */
254 static void tegra2_super_clk_init(struct clk *c)
255 {
256 u32 val;
257 int source;
258 int shift;
259 const struct clk_mux_sel *sel;
260 val = clk_readl(c->reg + SUPER_CLK_MUX);
261 c->state = ON;
262 BUG_ON(((val & SUPER_STATE_MASK) != SUPER_STATE_RUN) &&
263 ((val & SUPER_STATE_MASK) != SUPER_STATE_IDLE));
264 shift = ((val & SUPER_STATE_MASK) == SUPER_STATE_IDLE) ?
265 SUPER_IDLE_SOURCE_SHIFT : SUPER_RUN_SOURCE_SHIFT;
266 source = (val >> shift) & SUPER_SOURCE_MASK;
267 for (sel = c->inputs; sel->input != NULL; sel++) {
268 if (sel->value == source)
269 break;
270 }
271 BUG_ON(sel->input == NULL);
272 c->parent = sel->input;
273 }
274
275 static int tegra2_super_clk_enable(struct clk *c)
276 {
277 clk_writel(0, c->reg + SUPER_CLK_DIVIDER);
278 return 0;
279 }
280
281 static void tegra2_super_clk_disable(struct clk *c)
282 {
283 pr_debug("%s on clock %s\n", __func__, c->name);
284
285 /* oops - don't disable the CPU clock! */
286 BUG();
287 }
288
289 static int tegra2_super_clk_set_parent(struct clk *c, struct clk *p)
290 {
291 u32 val;
292 const struct clk_mux_sel *sel;
293 int shift;
294
295 val = clk_readl(c->reg + SUPER_CLK_MUX);;
296 BUG_ON(((val & SUPER_STATE_MASK) != SUPER_STATE_RUN) &&
297 ((val & SUPER_STATE_MASK) != SUPER_STATE_IDLE));
298 shift = ((val & SUPER_STATE_MASK) == SUPER_STATE_IDLE) ?
299 SUPER_IDLE_SOURCE_SHIFT : SUPER_RUN_SOURCE_SHIFT;
300 for (sel = c->inputs; sel->input != NULL; sel++) {
301 if (sel->input == p) {
302 val &= ~(SUPER_SOURCE_MASK << shift);
303 val |= sel->value << shift;
304
305 if (c->refcnt)
306 clk_enable_locked(p);
307
308 clk_writel(val, c->reg);
309
310 if (c->refcnt && c->parent)
311 clk_disable_locked(c->parent);
312
313 clk_reparent(c, p);
314 return 0;
315 }
316 }
317 return -EINVAL;
318 }
319
320 static struct clk_ops tegra_super_ops = {
321 .init = tegra2_super_clk_init,
322 .enable = tegra2_super_clk_enable,
323 .disable = tegra2_super_clk_disable,
324 .set_parent = tegra2_super_clk_set_parent,
325 };
326
327 /* virtual cpu clock functions */
328 /* some clocks can not be stopped (cpu, memory bus) while the SoC is running.
329 To change the frequency of these clocks, the parent pll may need to be
330 reprogrammed, so the clock must be moved off the pll, the pll reprogrammed,
331 and then the clock moved back to the pll. To hide this sequence, a virtual
332 clock handles it.
333 */
334 static void tegra2_cpu_clk_init(struct clk *c)
335 {
336 }
337
338 static int tegra2_cpu_clk_enable(struct clk *c)
339 {
340 return 0;
341 }
342
343 static void tegra2_cpu_clk_disable(struct clk *c)
344 {
345 pr_debug("%s on clock %s\n", __func__, c->name);
346
347 /* oops - don't disable the CPU clock! */
348 BUG();
349 }
350
351 static int tegra2_cpu_clk_set_rate(struct clk *c, unsigned long rate)
352 {
353 int ret;
354 ret = clk_set_parent_locked(c->parent, c->backup);
355 if (ret) {
356 pr_err("Failed to switch cpu to clock %s\n", c->backup->name);
357 return ret;
358 }
359
360 ret = clk_set_rate_locked(c->main, rate);
361 if (ret) {
362 pr_err("Failed to change cpu pll to %lu\n", rate);
363 return ret;
364 }
365
366 ret = clk_set_parent_locked(c->parent, c->main);
367 if (ret) {
368 pr_err("Failed to switch cpu to clock %s\n", c->main->name);
369 return ret;
370 }
371
372 return 0;
373 }
374
375 static struct clk_ops tegra_cpu_ops = {
376 .init = tegra2_cpu_clk_init,
377 .enable = tegra2_cpu_clk_enable,
378 .disable = tegra2_cpu_clk_disable,
379 .set_rate = tegra2_cpu_clk_set_rate,
380 };
381
382 /* bus clock functions */
383 static void tegra2_bus_clk_init(struct clk *c)
384 {
385 u32 val = clk_readl(c->reg);
386 c->state = ((val >> c->reg_shift) & BUS_CLK_DISABLE) ? OFF : ON;
387 c->div = ((val >> c->reg_shift) & BUS_CLK_DIV_MASK) + 1;
388 c->mul = 1;
389 }
390
391 static int tegra2_bus_clk_enable(struct clk *c)
392 {
393 u32 val = clk_readl(c->reg);
394 val &= ~(BUS_CLK_DISABLE << c->reg_shift);
395 clk_writel(val, c->reg);
396 return 0;
397 }
398
399 static void tegra2_bus_clk_disable(struct clk *c)
400 {
401 u32 val = clk_readl(c->reg);
402 val |= BUS_CLK_DISABLE << c->reg_shift;
403 clk_writel(val, c->reg);
404 }
405
406 static int tegra2_bus_clk_set_rate(struct clk *c, unsigned long rate)
407 {
408 u32 val = clk_readl(c->reg);
409 unsigned long parent_rate = c->parent->rate;
410 int i;
411 for (i = 1; i <= 4; i++) {
412 if (rate == parent_rate / i) {
413 val &= ~(BUS_CLK_DIV_MASK << c->reg_shift);
414 val |= (i - 1) << c->reg_shift;
415 clk_writel(val, c->reg);
416 c->div = i;
417 c->mul = 1;
418 return 0;
419 }
420 }
421 return -EINVAL;
422 }
423
424 static struct clk_ops tegra_bus_ops = {
425 .init = tegra2_bus_clk_init,
426 .enable = tegra2_bus_clk_enable,
427 .disable = tegra2_bus_clk_disable,
428 .set_rate = tegra2_bus_clk_set_rate,
429 };
430
431 /* PLL Functions */
432 static int tegra2_pll_clk_wait_for_lock(struct clk *c)
433 {
434 ktime_t before;
435
436 before = ktime_get();
437
438 while (!(clk_readl(c->reg + PLL_BASE) & PLL_BASE_LOCK)) {
439 if (ktime_us_delta(ktime_get(), before) > 5000) {
440 pr_err("Timed out waiting for lock bit on pll %s",
441 c->name);
442 return -1;
443 }
444 }
445
446 return 0;
447 }
448
449 static void tegra2_pll_clk_init(struct clk *c)
450 {
451 u32 val = clk_readl(c->reg + PLL_BASE);
452
453 c->state = (val & PLL_BASE_ENABLE) ? ON : OFF;
454
455 if (c->flags & PLL_FIXED && !(val & PLL_BASE_OVERRIDE)) {
456 pr_warning("Clock %s has unknown fixed frequency\n", c->name);
457 c->mul = 1;
458 c->div = 1;
459 } else if (val & PLL_BASE_BYPASS) {
460 c->mul = 1;
461 c->div = 1;
462 } else {
463 c->mul = (val & PLL_BASE_DIVN_MASK) >> PLL_BASE_DIVN_SHIFT;
464 c->div = (val & PLL_BASE_DIVM_MASK) >> PLL_BASE_DIVM_SHIFT;
465 if (c->flags & PLLU)
466 c->div *= (val & PLLU_BASE_POST_DIV) ? 1 : 2;
467 else
468 c->div *= (val & PLL_BASE_DIVP_MASK) ? 2 : 1;
469 }
470 }
471
472 static int tegra2_pll_clk_enable(struct clk *c)
473 {
474 u32 val;
475 pr_debug("%s on clock %s\n", __func__, c->name);
476
477 val = clk_readl(c->reg + PLL_BASE);
478 val &= ~PLL_BASE_BYPASS;
479 val |= PLL_BASE_ENABLE;
480 clk_writel(val, c->reg + PLL_BASE);
481
482 val = clk_readl(c->reg + PLL_MISC(c));
483 val |= PLL_MISC_LOCK_ENABLE(c);
484 clk_writel(val, c->reg + PLL_MISC(c));
485
486 tegra2_pll_clk_wait_for_lock(c);
487
488 return 0;
489 }
490
491 static void tegra2_pll_clk_disable(struct clk *c)
492 {
493 u32 val;
494 pr_debug("%s on clock %s\n", __func__, c->name);
495
496 val = clk_readl(c->reg);
497 val &= ~(PLL_BASE_BYPASS | PLL_BASE_ENABLE);
498 clk_writel(val, c->reg);
499 }
500
501 static int tegra2_pll_clk_set_rate(struct clk *c, unsigned long rate)
502 {
503 u32 val;
504 unsigned long input_rate;
505 const struct clk_pll_table *sel;
506
507 pr_debug("%s: %s %lu\n", __func__, c->name, rate);
508 BUG_ON(c->refcnt != 0);
509
510 input_rate = c->parent->rate;
511 for (sel = c->pll_table; sel->input_rate != 0; sel++) {
512 if (sel->input_rate == input_rate && sel->output_rate == rate) {
513 c->mul = sel->n;
514 c->div = sel->m * sel->p;
515
516 val = clk_readl(c->reg + PLL_BASE);
517 if (c->flags & PLL_FIXED)
518 val |= PLL_BASE_OVERRIDE;
519 val &= ~(PLL_BASE_DIVP_MASK | PLL_BASE_DIVN_MASK |
520 PLL_BASE_DIVM_MASK);
521 val |= (sel->m << PLL_BASE_DIVM_SHIFT) |
522 (sel->n << PLL_BASE_DIVN_SHIFT);
523 BUG_ON(sel->p < 1 || sel->p > 2);
524 if (c->flags & PLLU) {
525 if (sel->p == 1)
526 val |= PLLU_BASE_POST_DIV;
527 } else {
528 if (sel->p == 2)
529 val |= 1 << PLL_BASE_DIVP_SHIFT;
530 }
531 clk_writel(val, c->reg + PLL_BASE);
532
533 if (c->flags & PLL_HAS_CPCON) {
534 val = clk_readl(c->reg + PLL_MISC(c));
535 val &= ~PLL_MISC_CPCON_MASK;
536 val |= sel->cpcon << PLL_MISC_CPCON_SHIFT;
537 clk_writel(val, c->reg + PLL_MISC(c));
538 }
539
540 if (c->state == ON)
541 tegra2_pll_clk_enable(c);
542
543 return 0;
544 }
545 }
546 return -EINVAL;
547 }
548
549 static struct clk_ops tegra_pll_ops = {
550 .init = tegra2_pll_clk_init,
551 .enable = tegra2_pll_clk_enable,
552 .disable = tegra2_pll_clk_disable,
553 .set_rate = tegra2_pll_clk_set_rate,
554 };
555
556 static void tegra2_pllx_clk_init(struct clk *c)
557 {
558 tegra2_pll_clk_init(c);
559
560 if (tegra_sku_id() == 7)
561 c->max_rate = 750000000;
562 }
563
564 static struct clk_ops tegra_pllx_ops = {
565 .init = tegra2_pllx_clk_init,
566 .enable = tegra2_pll_clk_enable,
567 .disable = tegra2_pll_clk_disable,
568 .set_rate = tegra2_pll_clk_set_rate,
569 };
570
571 static int tegra2_plle_clk_enable(struct clk *c)
572 {
573 u32 val;
574
575 pr_debug("%s on clock %s\n", __func__, c->name);
576
577 mdelay(1);
578
579 val = clk_readl(c->reg + PLL_BASE);
580 if (!(val & PLLE_MISC_READY))
581 return -EBUSY;
582
583 val = clk_readl(c->reg + PLL_BASE);
584 val |= PLL_BASE_ENABLE | PLL_BASE_BYPASS;
585 clk_writel(val, c->reg + PLL_BASE);
586
587 return 0;
588 }
589
590 static struct clk_ops tegra_plle_ops = {
591 .init = tegra2_pll_clk_init,
592 .enable = tegra2_plle_clk_enable,
593 .set_rate = tegra2_pll_clk_set_rate,
594 };
595
596 /* Clock divider ops */
597 static void tegra2_pll_div_clk_init(struct clk *c)
598 {
599 u32 val = clk_readl(c->reg);
600 u32 divu71;
601 val >>= c->reg_shift;
602 c->state = (val & PLL_OUT_CLKEN) ? ON : OFF;
603 if (!(val & PLL_OUT_RESET_DISABLE))
604 c->state = OFF;
605
606 if (c->flags & DIV_U71) {
607 divu71 = (val & PLL_OUT_RATIO_MASK) >> PLL_OUT_RATIO_SHIFT;
608 c->div = (divu71 + 2);
609 c->mul = 2;
610 } else if (c->flags & DIV_2) {
611 c->div = 2;
612 c->mul = 1;
613 } else {
614 c->div = 1;
615 c->mul = 1;
616 }
617 }
618
619 static int tegra2_pll_div_clk_enable(struct clk *c)
620 {
621 u32 val;
622 u32 new_val;
623
624 pr_debug("%s: %s\n", __func__, c->name);
625 if (c->flags & DIV_U71) {
626 val = clk_readl(c->reg);
627 new_val = val >> c->reg_shift;
628 new_val &= 0xFFFF;
629
630 new_val |= PLL_OUT_CLKEN | PLL_OUT_RESET_DISABLE;
631
632 val &= ~(0xFFFF << c->reg_shift);
633 val |= new_val << c->reg_shift;
634 clk_writel(val, c->reg);
635 return 0;
636 } else if (c->flags & DIV_2) {
637 BUG_ON(!(c->flags & PLLD));
638 val = clk_readl(c->reg);
639 val &= ~PLLD_MISC_DIV_RST;
640 clk_writel(val, c->reg);
641 return 0;
642 }
643 return -EINVAL;
644 }
645
646 static void tegra2_pll_div_clk_disable(struct clk *c)
647 {
648 u32 val;
649 u32 new_val;
650
651 pr_debug("%s: %s\n", __func__, c->name);
652 if (c->flags & DIV_U71) {
653 val = clk_readl(c->reg);
654 new_val = val >> c->reg_shift;
655 new_val &= 0xFFFF;
656
657 new_val &= ~(PLL_OUT_CLKEN | PLL_OUT_RESET_DISABLE);
658
659 val &= ~(0xFFFF << c->reg_shift);
660 val |= new_val << c->reg_shift;
661 clk_writel(val, c->reg);
662 } else if (c->flags & DIV_2) {
663 BUG_ON(!(c->flags & PLLD));
664 val = clk_readl(c->reg);
665 val |= PLLD_MISC_DIV_RST;
666 clk_writel(val, c->reg);
667 }
668 }
669
670 static int tegra2_pll_div_clk_set_rate(struct clk *c, unsigned long rate)
671 {
672 u32 val;
673 u32 new_val;
674 int divider_u71;
675 pr_debug("%s: %s %lu\n", __func__, c->name, rate);
676 if (c->flags & DIV_U71) {
677 divider_u71 = clk_div71_get_divider(c->parent->rate, rate);
678 if (divider_u71 >= 0) {
679 val = clk_readl(c->reg);
680 new_val = val >> c->reg_shift;
681 new_val &= 0xFFFF;
682 if (c->flags & DIV_U71_FIXED)
683 new_val |= PLL_OUT_OVERRIDE;
684 new_val &= ~PLL_OUT_RATIO_MASK;
685 new_val |= divider_u71 << PLL_OUT_RATIO_SHIFT;
686
687 val &= ~(0xFFFF << c->reg_shift);
688 val |= new_val << c->reg_shift;
689 clk_writel(val, c->reg);
690 c->div = divider_u71 + 2;
691 c->mul = 2;
692 return 0;
693 }
694 } else if (c->flags & DIV_2) {
695 if (c->parent->rate == rate * 2)
696 return 0;
697 }
698 return -EINVAL;
699 }
700
701 static long tegra2_pll_div_clk_round_rate(struct clk *c, unsigned long rate)
702 {
703 int divider;
704 pr_debug("%s: %s %lu\n", __func__, c->name, rate);
705
706 if (c->flags & DIV_U71) {
707 divider = clk_div71_get_divider(c->parent->rate, rate);
708 if (divider < 0)
709 return divider;
710 return c->parent->rate * 2 / (divider + 2);
711 } else if (c->flags & DIV_2) {
712 return c->parent->rate / 2;
713 }
714 return -EINVAL;
715 }
716
717 static struct clk_ops tegra_pll_div_ops = {
718 .init = tegra2_pll_div_clk_init,
719 .enable = tegra2_pll_div_clk_enable,
720 .disable = tegra2_pll_div_clk_disable,
721 .set_rate = tegra2_pll_div_clk_set_rate,
722 .round_rate = tegra2_pll_div_clk_round_rate,
723 };
724
725 /* Periph clk ops */
726
727 static void tegra2_periph_clk_init(struct clk *c)
728 {
729 u32 val = clk_readl(c->reg);
730 const struct clk_mux_sel *mux = 0;
731 const struct clk_mux_sel *sel;
732 if (c->flags & MUX) {
733 for (sel = c->inputs; sel->input != NULL; sel++) {
734 if (val >> PERIPH_CLK_SOURCE_SHIFT == sel->value)
735 mux = sel;
736 }
737 BUG_ON(!mux);
738
739 c->parent = mux->input;
740 } else {
741 c->parent = c->inputs[0].input;
742 }
743
744 if (c->flags & DIV_U71) {
745 u32 divu71 = val & PERIPH_CLK_SOURCE_DIVU71_MASK;
746 c->div = divu71 + 2;
747 c->mul = 2;
748 } else if (c->flags & DIV_U16) {
749 u32 divu16 = val & PERIPH_CLK_SOURCE_DIVU16_MASK;
750 c->div = divu16 + 1;
751 c->mul = 1;
752 } else {
753 c->div = 1;
754 c->mul = 1;
755 }
756
757 c->state = ON;
758 if (!(clk_readl(CLK_OUT_ENB + PERIPH_CLK_TO_ENB_REG(c)) &
759 PERIPH_CLK_TO_ENB_BIT(c)))
760 c->state = OFF;
761 if (!(c->flags & PERIPH_NO_RESET))
762 if (clk_readl(RST_DEVICES + PERIPH_CLK_TO_ENB_REG(c)) &
763 PERIPH_CLK_TO_ENB_BIT(c))
764 c->state = OFF;
765 }
766
767 static int tegra2_periph_clk_enable(struct clk *c)
768 {
769 u32 val;
770 pr_debug("%s on clock %s\n", __func__, c->name);
771
772 clk_writel(PERIPH_CLK_TO_ENB_BIT(c),
773 CLK_OUT_ENB_SET + PERIPH_CLK_TO_ENB_SET_REG(c));
774 if (!(c->flags & PERIPH_NO_RESET) && !(c->flags & PERIPH_MANUAL_RESET))
775 clk_writel(PERIPH_CLK_TO_ENB_BIT(c),
776 RST_DEVICES_CLR + PERIPH_CLK_TO_ENB_SET_REG(c));
777 if (c->flags & PERIPH_EMC_ENB) {
778 /* The EMC peripheral clock has 2 extra enable bits */
779 /* FIXME: Do they need to be disabled? */
780 val = clk_readl(c->reg);
781 val |= 0x3 << 24;
782 clk_writel(val, c->reg);
783 }
784 return 0;
785 }
786
787 static void tegra2_periph_clk_disable(struct clk *c)
788 {
789 pr_debug("%s on clock %s\n", __func__, c->name);
790
791 clk_writel(PERIPH_CLK_TO_ENB_BIT(c),
792 CLK_OUT_ENB_CLR + PERIPH_CLK_TO_ENB_SET_REG(c));
793 }
794
795 void tegra2_periph_reset_deassert(struct clk *c)
796 {
797 pr_debug("%s on clock %s\n", __func__, c->name);
798 if (!(c->flags & PERIPH_NO_RESET))
799 clk_writel(PERIPH_CLK_TO_ENB_BIT(c),
800 RST_DEVICES_CLR + PERIPH_CLK_TO_ENB_SET_REG(c));
801 }
802
803 void tegra2_periph_reset_assert(struct clk *c)
804 {
805 pr_debug("%s on clock %s\n", __func__, c->name);
806 if (!(c->flags & PERIPH_NO_RESET))
807 clk_writel(PERIPH_CLK_TO_ENB_BIT(c),
808 RST_DEVICES_SET + PERIPH_CLK_TO_ENB_SET_REG(c));
809 }
810
811
812 static int tegra2_periph_clk_set_parent(struct clk *c, struct clk *p)
813 {
814 u32 val;
815 const struct clk_mux_sel *sel;
816 pr_debug("%s: %s %s\n", __func__, c->name, p->name);
817 for (sel = c->inputs; sel->input != NULL; sel++) {
818 if (sel->input == p) {
819 val = clk_readl(c->reg);
820 val &= ~PERIPH_CLK_SOURCE_MASK;
821 val |= (sel->value) << PERIPH_CLK_SOURCE_SHIFT;
822
823 if (c->refcnt)
824 clk_enable_locked(p);
825
826 clk_writel(val, c->reg);
827
828 if (c->refcnt && c->parent)
829 clk_disable_locked(c->parent);
830
831 clk_reparent(c, p);
832 return 0;
833 }
834 }
835
836 return -EINVAL;
837 }
838
839 static int tegra2_periph_clk_set_rate(struct clk *c, unsigned long rate)
840 {
841 u32 val;
842 int divider;
843 pr_debug("%s: %lu\n", __func__, rate);
844 if (c->flags & DIV_U71) {
845 divider = clk_div71_get_divider(c->parent->rate, rate);
846 if (divider >= 0) {
847 val = clk_readl(c->reg);
848 val &= ~PERIPH_CLK_SOURCE_DIVU71_MASK;
849 val |= divider;
850 clk_writel(val, c->reg);
851 c->div = divider + 2;
852 c->mul = 2;
853 return 0;
854 }
855 } else if (c->flags & DIV_U16) {
856 divider = clk_div16_get_divider(c->parent->rate, rate);
857 if (divider >= 0) {
858 val = clk_readl(c->reg);
859 val &= ~PERIPH_CLK_SOURCE_DIVU16_MASK;
860 val |= divider;
861 clk_writel(val, c->reg);
862 c->div = divider + 1;
863 c->mul = 1;
864 return 0;
865 }
866 } else if (c->parent->rate <= rate) {
867 c->div = 1;
868 c->mul = 1;
869 return 0;
870 }
871 return -EINVAL;
872 }
873
874 static long tegra2_periph_clk_round_rate(struct clk *c,
875 unsigned long rate)
876 {
877 int divider;
878 pr_debug("%s: %s %lu\n", __func__, c->name, rate);
879
880 if (c->flags & DIV_U71) {
881 divider = clk_div71_get_divider(c->parent->rate, rate);
882 if (divider < 0)
883 return divider;
884
885 return c->parent->rate * 2 / (divider + 2);
886 } else if (c->flags & DIV_U16) {
887 divider = clk_div16_get_divider(c->parent->rate, rate);
888 if (divider < 0)
889 return divider;
890 return c->parent->rate / (divider + 1);
891 }
892 return -EINVAL;
893 }
894
895 static struct clk_ops tegra_periph_clk_ops = {
896 .init = &tegra2_periph_clk_init,
897 .enable = &tegra2_periph_clk_enable,
898 .disable = &tegra2_periph_clk_disable,
899 .set_parent = &tegra2_periph_clk_set_parent,
900 .set_rate = &tegra2_periph_clk_set_rate,
901 .round_rate = &tegra2_periph_clk_round_rate,
902 };
903
904 /* Clock doubler ops */
905 static void tegra2_clk_double_init(struct clk *c)
906 {
907 c->mul = 2;
908 c->div = 1;
909 c->state = ON;
910 if (!(clk_readl(CLK_OUT_ENB + PERIPH_CLK_TO_ENB_REG(c)) &
911 PERIPH_CLK_TO_ENB_BIT(c)))
912 c->state = OFF;
913 };
914
915 static int tegra2_clk_double_set_rate(struct clk *c, unsigned long rate)
916 {
917 if (rate != 2 * c->parent->rate)
918 return -EINVAL;
919 c->mul = 2;
920 c->div = 1;
921 return 0;
922 }
923
924 static struct clk_ops tegra_clk_double_ops = {
925 .init = &tegra2_clk_double_init,
926 .enable = &tegra2_periph_clk_enable,
927 .disable = &tegra2_periph_clk_disable,
928 .set_rate = &tegra2_clk_double_set_rate,
929 };
930
931 static void tegra2_audio_sync_clk_init(struct clk *c)
932 {
933 int source;
934 const struct clk_mux_sel *sel;
935 u32 val = clk_readl(c->reg);
936 c->state = (val & (1<<4)) ? OFF : ON;
937 source = val & 0xf;
938 for (sel = c->inputs; sel->input != NULL; sel++)
939 if (sel->value == source)
940 break;
941 BUG_ON(sel->input == NULL);
942 c->parent = sel->input;
943 }
944
945 static int tegra2_audio_sync_clk_enable(struct clk *c)
946 {
947 clk_writel(0, c->reg);
948 return 0;
949 }
950
951 static void tegra2_audio_sync_clk_disable(struct clk *c)
952 {
953 clk_writel(1, c->reg);
954 }
955
956 static int tegra2_audio_sync_clk_set_parent(struct clk *c, struct clk *p)
957 {
958 u32 val;
959 const struct clk_mux_sel *sel;
960 for (sel = c->inputs; sel->input != NULL; sel++) {
961 if (sel->input == p) {
962 val = clk_readl(c->reg);
963 val &= ~0xf;
964 val |= sel->value;
965
966 if (c->refcnt)
967 clk_enable_locked(p);
968
969 clk_writel(val, c->reg);
970
971 if (c->refcnt && c->parent)
972 clk_disable_locked(c->parent);
973
974 clk_reparent(c, p);
975 return 0;
976 }
977 }
978
979 return -EINVAL;
980 }
981
982 static int tegra2_audio_sync_clk_set_rate(struct clk *c, unsigned long rate)
983 {
984 unsigned long parent_rate;
985 if (!c->parent) {
986 pr_err("%s: clock has no parent\n", __func__);
987 return -EINVAL;
988 }
989 parent_rate = c->parent->rate;
990 if (rate != parent_rate) {
991 pr_err("%s: %s/%ld differs from parent %s/%ld\n",
992 __func__,
993 c->name, rate,
994 c->parent->name, parent_rate);
995 return -EINVAL;
996 }
997 c->rate = parent_rate;
998 return 0;
999 }
1000
1001 static struct clk_ops tegra_audio_sync_clk_ops = {
1002 .init = tegra2_audio_sync_clk_init,
1003 .enable = tegra2_audio_sync_clk_enable,
1004 .disable = tegra2_audio_sync_clk_disable,
1005 .set_rate = tegra2_audio_sync_clk_set_rate,
1006 .set_parent = tegra2_audio_sync_clk_set_parent,
1007 };
1008
1009 /* Clock definitions */
1010 static struct clk tegra_clk_32k = {
1011 .name = "clk_32k",
1012 .rate = 32768,
1013 .ops = NULL,
1014 .max_rate = 32768,
1015 };
1016
1017 static struct clk_pll_table tegra_pll_s_table[] = {
1018 {32768, 12000000, 366, 1, 1, 0},
1019 {32768, 13000000, 397, 1, 1, 0},
1020 {32768, 19200000, 586, 1, 1, 0},
1021 {32768, 26000000, 793, 1, 1, 0},
1022 {0, 0, 0, 0, 0, 0},
1023 };
1024
1025 static struct clk tegra_pll_s = {
1026 .name = "pll_s",
1027 .flags = PLL_ALT_MISC_REG,
1028 .ops = &tegra_pll_ops,
1029 .reg = 0xf0,
1030 .input_min = 32768,
1031 .input_max = 32768,
1032 .parent = &tegra_clk_32k,
1033 .cf_min = 0, /* FIXME */
1034 .cf_max = 0, /* FIXME */
1035 .vco_min = 12000000,
1036 .vco_max = 26000000,
1037 .pll_table = tegra_pll_s_table,
1038 .max_rate = 26000000,
1039 };
1040
1041 static struct clk_mux_sel tegra_clk_m_sel[] = {
1042 { .input = &tegra_clk_32k, .value = 0},
1043 { .input = &tegra_pll_s, .value = 1},
1044 { 0, 0},
1045 };
1046 static struct clk tegra_clk_m = {
1047 .name = "clk_m",
1048 .flags = ENABLE_ON_INIT,
1049 .ops = &tegra_clk_m_ops,
1050 .inputs = tegra_clk_m_sel,
1051 .reg = 0x1fc,
1052 .reg_mask = (1<<28),
1053 .reg_shift = 28,
1054 .max_rate = 26000000,
1055 };
1056
1057 static struct clk_pll_table tegra_pll_c_table[] = {
1058 { 0, 0, 0, 0, 0, 0 },
1059 };
1060
1061 static struct clk tegra_pll_c = {
1062 .name = "pll_c",
1063 .flags = PLL_HAS_CPCON,
1064 .ops = &tegra_pll_ops,
1065 .reg = 0x80,
1066 .input_min = 2000000,
1067 .input_max = 31000000,
1068 .parent = &tegra_clk_m,
1069 .cf_min = 1000000,
1070 .cf_max = 6000000,
1071 .vco_min = 20000000,
1072 .vco_max = 1400000000,
1073 .pll_table = tegra_pll_c_table,
1074 .max_rate = 600000000,
1075 };
1076
1077 static struct clk tegra_pll_c_out1 = {
1078 .name = "pll_c_out1",
1079 .ops = &tegra_pll_div_ops,
1080 .flags = DIV_U71,
1081 .parent = &tegra_pll_c,
1082 .reg = 0x84,
1083 .reg_shift = 0,
1084 .max_rate = 600000000,
1085 };
1086
1087 static struct clk_pll_table tegra_pll_m_table[] = {
1088 { 12000000, 666000000, 666, 12, 1, 8},
1089 { 13000000, 666000000, 666, 13, 1, 8},
1090 { 19200000, 666000000, 555, 16, 1, 8},
1091 { 26000000, 666000000, 666, 26, 1, 8},
1092 { 12000000, 600000000, 600, 12, 1, 8},
1093 { 13000000, 600000000, 600, 13, 1, 8},
1094 { 19200000, 600000000, 375, 12, 1, 6},
1095 { 26000000, 600000000, 600, 26, 1, 8},
1096 { 0, 0, 0, 0, 0, 0 },
1097 };
1098
1099 static struct clk tegra_pll_m = {
1100 .name = "pll_m",
1101 .flags = PLL_HAS_CPCON,
1102 .ops = &tegra_pll_ops,
1103 .reg = 0x90,
1104 .input_min = 2000000,
1105 .input_max = 31000000,
1106 .parent = &tegra_clk_m,
1107 .cf_min = 1000000,
1108 .cf_max = 6000000,
1109 .vco_min = 20000000,
1110 .vco_max = 1200000000,
1111 .pll_table = tegra_pll_m_table,
1112 .max_rate = 800000000,
1113 };
1114
1115 static struct clk tegra_pll_m_out1 = {
1116 .name = "pll_m_out1",
1117 .ops = &tegra_pll_div_ops,
1118 .flags = DIV_U71,
1119 .parent = &tegra_pll_m,
1120 .reg = 0x94,
1121 .reg_shift = 0,
1122 .max_rate = 600000000,
1123 };
1124
1125 static struct clk_pll_table tegra_pll_p_table[] = {
1126 { 12000000, 216000000, 432, 12, 2, 8},
1127 { 13000000, 216000000, 432, 13, 2, 8},
1128 { 19200000, 216000000, 90, 4, 2, 1},
1129 { 26000000, 216000000, 432, 26, 2, 8},
1130 { 12000000, 432000000, 432, 12, 1, 8},
1131 { 13000000, 432000000, 432, 13, 1, 8},
1132 { 19200000, 432000000, 90, 4, 1, 1},
1133 { 26000000, 432000000, 432, 26, 1, 8},
1134 { 0, 0, 0, 0, 0, 0 },
1135 };
1136
1137 static struct clk tegra_pll_p = {
1138 .name = "pll_p",
1139 .flags = ENABLE_ON_INIT | PLL_FIXED | PLL_HAS_CPCON,
1140 .ops = &tegra_pll_ops,
1141 .reg = 0xa0,
1142 .input_min = 2000000,
1143 .input_max = 31000000,
1144 .parent = &tegra_clk_m,
1145 .cf_min = 1000000,
1146 .cf_max = 6000000,
1147 .vco_min = 20000000,
1148 .vco_max = 1400000000,
1149 .pll_table = tegra_pll_p_table,
1150 .max_rate = 432000000,
1151 };
1152
1153 static struct clk tegra_pll_p_out1 = {
1154 .name = "pll_p_out1",
1155 .ops = &tegra_pll_div_ops,
1156 .flags = ENABLE_ON_INIT | DIV_U71 | DIV_U71_FIXED,
1157 .parent = &tegra_pll_p,
1158 .reg = 0xa4,
1159 .reg_shift = 0,
1160 .max_rate = 432000000,
1161 };
1162
1163 static struct clk tegra_pll_p_out2 = {
1164 .name = "pll_p_out2",
1165 .ops = &tegra_pll_div_ops,
1166 .flags = ENABLE_ON_INIT | DIV_U71 | DIV_U71_FIXED,
1167 .parent = &tegra_pll_p,
1168 .reg = 0xa4,
1169 .reg_shift = 16,
1170 .max_rate = 432000000,
1171 };
1172
1173 static struct clk tegra_pll_p_out3 = {
1174 .name = "pll_p_out3",
1175 .ops = &tegra_pll_div_ops,
1176 .flags = ENABLE_ON_INIT | DIV_U71 | DIV_U71_FIXED,
1177 .parent = &tegra_pll_p,
1178 .reg = 0xa8,
1179 .reg_shift = 0,
1180 .max_rate = 432000000,
1181 };
1182
1183 static struct clk tegra_pll_p_out4 = {
1184 .name = "pll_p_out4",
1185 .ops = &tegra_pll_div_ops,
1186 .flags = ENABLE_ON_INIT | DIV_U71 | DIV_U71_FIXED,
1187 .parent = &tegra_pll_p,
1188 .reg = 0xa8,
1189 .reg_shift = 16,
1190 .max_rate = 432000000,
1191 };
1192
1193 static struct clk_pll_table tegra_pll_a_table[] = {
1194 { 28800000, 56448000, 49, 25, 1, 1},
1195 { 28800000, 73728000, 64, 25, 1, 1},
1196 { 28800000, 11289600, 49, 25, 1, 1},
1197 { 28800000, 12288000, 64, 25, 1, 1},
1198 { 28800000, 24000000, 5, 6, 1, 1},
1199 { 0, 0, 0, 0, 0, 0 },
1200 };
1201
1202 static struct clk tegra_pll_a = {
1203 .name = "pll_a",
1204 .flags = PLL_HAS_CPCON,
1205 .ops = &tegra_pll_ops,
1206 .reg = 0xb0,
1207 .input_min = 2000000,
1208 .input_max = 31000000,
1209 .parent = &tegra_pll_p_out1,
1210 .cf_min = 1000000,
1211 .cf_max = 6000000,
1212 .vco_min = 20000000,
1213 .vco_max = 1400000000,
1214 .pll_table = tegra_pll_a_table,
1215 .max_rate = 56448000,
1216 };
1217
1218 static struct clk tegra_pll_a_out0 = {
1219 .name = "pll_a_out0",
1220 .ops = &tegra_pll_div_ops,
1221 .flags = DIV_U71,
1222 .parent = &tegra_pll_a,
1223 .reg = 0xb4,
1224 .reg_shift = 0,
1225 .max_rate = 56448000,
1226 };
1227
1228 static struct clk_pll_table tegra_pll_d_table[] = {
1229 { 12000000, 1000000000, 1000, 12, 1, 12},
1230 { 13000000, 1000000000, 1000, 13, 1, 12},
1231 { 19200000, 1000000000, 625, 12, 1, 8},
1232 { 26000000, 1000000000, 1000, 26, 1, 12},
1233 { 0, 0, 0, 0, 0, 0 },
1234 };
1235
1236 static struct clk tegra_pll_d = {
1237 .name = "pll_d",
1238 .flags = PLL_HAS_CPCON | PLLD,
1239 .ops = &tegra_pll_ops,
1240 .reg = 0xd0,
1241 .input_min = 2000000,
1242 .input_max = 40000000,
1243 .parent = &tegra_clk_m,
1244 .cf_min = 1000000,
1245 .cf_max = 6000000,
1246 .vco_min = 40000000,
1247 .vco_max = 1000000000,
1248 .pll_table = tegra_pll_d_table,
1249 .max_rate = 1000000000,
1250 };
1251
1252 static struct clk tegra_pll_d_out0 = {
1253 .name = "pll_d_out0",
1254 .ops = &tegra_pll_div_ops,
1255 .flags = DIV_2 | PLLD,
1256 .parent = &tegra_pll_d,
1257 .max_rate = 500000000,
1258 };
1259
1260 static struct clk_pll_table tegra_pll_u_table[] = {
1261 { 12000000, 480000000, 960, 12, 2, 0},
1262 { 13000000, 480000000, 960, 13, 2, 0},
1263 { 19200000, 480000000, 200, 4, 2, 0},
1264 { 26000000, 480000000, 960, 26, 2, 0},
1265 { 0, 0, 0, 0, 0, 0 },
1266 };
1267
1268 static struct clk tegra_pll_u = {
1269 .name = "pll_u",
1270 .flags = PLLU,
1271 .ops = &tegra_pll_ops,
1272 .reg = 0xc0,
1273 .input_min = 2000000,
1274 .input_max = 40000000,
1275 .parent = &tegra_clk_m,
1276 .cf_min = 1000000,
1277 .cf_max = 6000000,
1278 .vco_min = 480000000,
1279 .vco_max = 960000000,
1280 .pll_table = tegra_pll_u_table,
1281 .max_rate = 480000000,
1282 };
1283
1284 static struct clk_pll_table tegra_pll_x_table[] = {
1285 /* 1 GHz */
1286 { 12000000, 1000000000, 1000, 12, 1, 12},
1287 { 13000000, 1000000000, 1000, 13, 1, 12},
1288 { 19200000, 1000000000, 625, 12, 1, 8},
1289 { 26000000, 1000000000, 1000, 26, 1, 12},
1290
1291 /* 912 MHz */
1292 { 12000000, 912000000, 912, 12, 1, 12},
1293 { 13000000, 912000000, 912, 13, 1, 12},
1294 { 19200000, 912000000, 760, 16, 1, 8},
1295 { 26000000, 912000000, 912, 26, 1, 12},
1296
1297 /* 816 MHz */
1298 { 12000000, 816000000, 816, 12, 1, 12},
1299 { 13000000, 816000000, 816, 13, 1, 12},
1300 { 19200000, 816000000, 680, 16, 1, 8},
1301 { 26000000, 816000000, 816, 26, 1, 12},
1302
1303 /* 760 MHz */
1304 { 12000000, 760000000, 760, 12, 1, 12},
1305 { 13000000, 760000000, 760, 13, 1, 12},
1306 { 19200000, 760000000, 950, 24, 1, 8},
1307 { 26000000, 760000000, 760, 26, 1, 12},
1308
1309 /* 608 MHz */
1310 { 12000000, 608000000, 760, 12, 1, 12},
1311 { 13000000, 608000000, 760, 13, 1, 12},
1312 { 19200000, 608000000, 380, 12, 1, 8},
1313 { 26000000, 608000000, 760, 26, 1, 12},
1314
1315 /* 456 MHz */
1316 { 12000000, 456000000, 456, 12, 1, 12},
1317 { 13000000, 456000000, 456, 13, 1, 12},
1318 { 19200000, 456000000, 380, 16, 1, 8},
1319 { 26000000, 456000000, 456, 26, 1, 12},
1320
1321 /* 312 MHz */
1322 { 12000000, 312000000, 312, 12, 1, 12},
1323 { 13000000, 312000000, 312, 13, 1, 12},
1324 { 19200000, 312000000, 260, 16, 1, 8},
1325 { 26000000, 312000000, 312, 26, 1, 12},
1326
1327 { 0, 0, 0, 0, 0, 0 },
1328 };
1329
1330 static struct clk tegra_pll_x = {
1331 .name = "pll_x",
1332 .flags = PLL_HAS_CPCON | PLL_ALT_MISC_REG,
1333 .ops = &tegra_pllx_ops,
1334 .reg = 0xe0,
1335 .input_min = 2000000,
1336 .input_max = 31000000,
1337 .parent = &tegra_clk_m,
1338 .cf_min = 1000000,
1339 .cf_max = 6000000,
1340 .vco_min = 20000000,
1341 .vco_max = 1200000000,
1342 .pll_table = tegra_pll_x_table,
1343 .max_rate = 1000000000,
1344 };
1345
1346 static struct clk_pll_table tegra_pll_e_table[] = {
1347 { 12000000, 100000000, 200, 24, 1, 0 },
1348 { 0, 0, 0, 0, 0, 0 },
1349 };
1350
1351 static struct clk tegra_pll_e = {
1352 .name = "pll_e",
1353 .flags = PLL_ALT_MISC_REG,
1354 .ops = &tegra_plle_ops,
1355 .input_min = 12000000,
1356 .input_max = 12000000,
1357 .max_rate = 100000000,
1358 .parent = &tegra_clk_m,
1359 .reg = 0xe8,
1360 .pll_table = tegra_pll_e_table,
1361 };
1362
1363 static struct clk tegra_clk_d = {
1364 .name = "clk_d",
1365 .flags = PERIPH_NO_RESET,
1366 .ops = &tegra_clk_double_ops,
1367 .clk_num = 90,
1368 .reg = 0x34,
1369 .reg_shift = 12,
1370 .parent = &tegra_clk_m,
1371 .max_rate = 52000000,
1372 };
1373
1374 /* initialized before peripheral clocks */
1375 static struct clk_mux_sel mux_audio_sync_clk[8+1];
1376 static const struct audio_sources {
1377 const char *name;
1378 int value;
1379 } mux_audio_sync_clk_sources[] = {
1380 { .name = "spdif_in", .value = 0 },
1381 { .name = "i2s1", .value = 1 },
1382 { .name = "i2s2", .value = 2 },
1383 { .name = "pll_a_out0", .value = 4 },
1384 #if 0 /* FIXME: not implemented */
1385 { .name = "ac97", .value = 3 },
1386 { .name = "ext_audio_clk2", .value = 5 },
1387 { .name = "ext_audio_clk1", .value = 6 },
1388 { .name = "ext_vimclk", .value = 7 },
1389 #endif
1390 { 0, 0 }
1391 };
1392
1393 static struct clk tegra_clk_audio = {
1394 .name = "audio",
1395 .inputs = mux_audio_sync_clk,
1396 .reg = 0x38,
1397 .max_rate = 24000000,
1398 .ops = &tegra_audio_sync_clk_ops
1399 };
1400
1401 static struct clk tegra_clk_audio_2x = {
1402 .name = "audio_2x",
1403 .flags = PERIPH_NO_RESET,
1404 .max_rate = 48000000,
1405 .ops = &tegra_clk_double_ops,
1406 .clk_num = 89,
1407 .reg = 0x34,
1408 .reg_shift = 8,
1409 .parent = &tegra_clk_audio,
1410 };
1411
1412 struct clk_lookup tegra_audio_clk_lookups[] = {
1413 { .con_id = "audio", .clk = &tegra_clk_audio },
1414 { .con_id = "audio_2x", .clk = &tegra_clk_audio_2x }
1415 };
1416
1417 /* This is called after peripheral clocks are initialized, as the
1418 * audio_sync clock depends on some of the peripheral clocks.
1419 */
1420
1421 static void init_audio_sync_clock_mux(void)
1422 {
1423 int i;
1424 struct clk_mux_sel *sel = mux_audio_sync_clk;
1425 const struct audio_sources *src = mux_audio_sync_clk_sources;
1426 struct clk_lookup *lookup;
1427
1428 for (i = 0; src->name; i++, sel++, src++) {
1429 sel->input = tegra_get_clock_by_name(src->name);
1430 if (!sel->input)
1431 pr_err("%s: could not find clk %s\n", __func__,
1432 src->name);
1433 sel->value = src->value;
1434 }
1435
1436 lookup = tegra_audio_clk_lookups;
1437 for (i = 0; i < ARRAY_SIZE(tegra_audio_clk_lookups); i++, lookup++) {
1438 clk_init(lookup->clk);
1439 clkdev_add(lookup);
1440 }
1441 }
1442
1443 static struct clk_mux_sel mux_cclk[] = {
1444 { .input = &tegra_clk_m, .value = 0},
1445 { .input = &tegra_pll_c, .value = 1},
1446 { .input = &tegra_clk_32k, .value = 2},
1447 { .input = &tegra_pll_m, .value = 3},
1448 { .input = &tegra_pll_p, .value = 4},
1449 { .input = &tegra_pll_p_out4, .value = 5},
1450 { .input = &tegra_pll_p_out3, .value = 6},
1451 { .input = &tegra_clk_d, .value = 7},
1452 { .input = &tegra_pll_x, .value = 8},
1453 { 0, 0},
1454 };
1455
1456 static struct clk_mux_sel mux_sclk[] = {
1457 { .input = &tegra_clk_m, .value = 0},
1458 { .input = &tegra_pll_c_out1, .value = 1},
1459 { .input = &tegra_pll_p_out4, .value = 2},
1460 { .input = &tegra_pll_p_out3, .value = 3},
1461 { .input = &tegra_pll_p_out2, .value = 4},
1462 { .input = &tegra_clk_d, .value = 5},
1463 { .input = &tegra_clk_32k, .value = 6},
1464 { .input = &tegra_pll_m_out1, .value = 7},
1465 { 0, 0},
1466 };
1467
1468 static struct clk tegra_clk_cclk = {
1469 .name = "cclk",
1470 .inputs = mux_cclk,
1471 .reg = 0x20,
1472 .ops = &tegra_super_ops,
1473 .max_rate = 1000000000,
1474 };
1475
1476 static struct clk tegra_clk_sclk = {
1477 .name = "sclk",
1478 .inputs = mux_sclk,
1479 .reg = 0x28,
1480 .ops = &tegra_super_ops,
1481 .max_rate = 600000000,
1482 };
1483
1484 static struct clk tegra_clk_virtual_cpu = {
1485 .name = "cpu",
1486 .parent = &tegra_clk_cclk,
1487 .main = &tegra_pll_x,
1488 .backup = &tegra_clk_m,
1489 .ops = &tegra_cpu_ops,
1490 .max_rate = 1000000000,
1491 .dvfs = &tegra_dvfs_virtual_cpu_dvfs,
1492 };
1493
1494 static struct clk tegra_clk_hclk = {
1495 .name = "hclk",
1496 .flags = DIV_BUS,
1497 .parent = &tegra_clk_sclk,
1498 .reg = 0x30,
1499 .reg_shift = 4,
1500 .ops = &tegra_bus_ops,
1501 .max_rate = 240000000,
1502 };
1503
1504 static struct clk tegra_clk_pclk = {
1505 .name = "pclk",
1506 .flags = DIV_BUS,
1507 .parent = &tegra_clk_hclk,
1508 .reg = 0x30,
1509 .reg_shift = 0,
1510 .ops = &tegra_bus_ops,
1511 .max_rate = 108000000,
1512 };
1513
1514 static struct clk_mux_sel mux_pllm_pllc_pllp_plla[] = {
1515 { .input = &tegra_pll_m, .value = 0},
1516 { .input = &tegra_pll_c, .value = 1},
1517 { .input = &tegra_pll_p, .value = 2},
1518 { .input = &tegra_pll_a_out0, .value = 3},
1519 { 0, 0},
1520 };
1521
1522 static struct clk_mux_sel mux_pllm_pllc_pllp_clkm[] = {
1523 { .input = &tegra_pll_m, .value = 0},
1524 { .input = &tegra_pll_c, .value = 1},
1525 { .input = &tegra_pll_p, .value = 2},
1526 { .input = &tegra_clk_m, .value = 3},
1527 { 0, 0},
1528 };
1529
1530 static struct clk_mux_sel mux_pllp_pllc_pllm_clkm[] = {
1531 { .input = &tegra_pll_p, .value = 0},
1532 { .input = &tegra_pll_c, .value = 1},
1533 { .input = &tegra_pll_m, .value = 2},
1534 { .input = &tegra_clk_m, .value = 3},
1535 { 0, 0},
1536 };
1537
1538 static struct clk_mux_sel mux_pllaout0_audio2x_pllp_clkm[] = {
1539 {.input = &tegra_pll_a_out0, .value = 0},
1540 {.input = &tegra_clk_audio_2x, .value = 1},
1541 {.input = &tegra_pll_p, .value = 2},
1542 {.input = &tegra_clk_m, .value = 3},
1543 { 0, 0},
1544 };
1545
1546 static struct clk_mux_sel mux_pllp_plld_pllc_clkm[] = {
1547 {.input = &tegra_pll_p, .value = 0},
1548 {.input = &tegra_pll_d_out0, .value = 1},
1549 {.input = &tegra_pll_c, .value = 2},
1550 {.input = &tegra_clk_m, .value = 3},
1551 { 0, 0},
1552 };
1553
1554 static struct clk_mux_sel mux_pllp_pllc_audio_clkm_clk32[] = {
1555 {.input = &tegra_pll_p, .value = 0},
1556 {.input = &tegra_pll_c, .value = 1},
1557 {.input = &tegra_clk_audio, .value = 2},
1558 {.input = &tegra_clk_m, .value = 3},
1559 {.input = &tegra_clk_32k, .value = 4},
1560 { 0, 0},
1561 };
1562
1563 static struct clk_mux_sel mux_pllp_pllc_pllm[] = {
1564 {.input = &tegra_pll_p, .value = 0},
1565 {.input = &tegra_pll_c, .value = 1},
1566 {.input = &tegra_pll_m, .value = 2},
1567 { 0, 0},
1568 };
1569
1570 static struct clk_mux_sel mux_clk_m[] = {
1571 { .input = &tegra_clk_m, .value = 0},
1572 { 0, 0},
1573 };
1574
1575 static struct clk_mux_sel mux_pllp_out3[] = {
1576 { .input = &tegra_pll_p_out3, .value = 0},
1577 { 0, 0},
1578 };
1579
1580 static struct clk_mux_sel mux_plld[] = {
1581 { .input = &tegra_pll_d, .value = 0},
1582 { 0, 0},
1583 };
1584
1585 static struct clk_mux_sel mux_clk_32k[] = {
1586 { .input = &tegra_clk_32k, .value = 0},
1587 { 0, 0},
1588 };
1589
1590 #define PERIPH_CLK(_name, _dev, _con, _clk_num, _reg, _max, _inputs, _flags) \
1591 { \
1592 .name = _name, \
1593 .lookup = { \
1594 .dev_id = _dev, \
1595 .con_id = _con, \
1596 }, \
1597 .ops = &tegra_periph_clk_ops, \
1598 .clk_num = _clk_num, \
1599 .reg = _reg, \
1600 .inputs = _inputs, \
1601 .flags = _flags, \
1602 .max_rate = _max, \
1603 }
1604
1605 struct clk tegra_periph_clks[] = {
1606 PERIPH_CLK("rtc", "rtc-tegra", NULL, 4, 0, 32768, mux_clk_32k, PERIPH_NO_RESET),
1607 PERIPH_CLK("timer", "timer", NULL, 5, 0, 26000000, mux_clk_m, 0),
1608 PERIPH_CLK("i2s1", "i2s.0", NULL, 11, 0x100, 26000000, mux_pllaout0_audio2x_pllp_clkm, MUX | DIV_U71),
1609 PERIPH_CLK("i2s2", "i2s.1", NULL, 18, 0x104, 26000000, mux_pllaout0_audio2x_pllp_clkm, MUX | DIV_U71),
1610 /* FIXME: spdif has 2 clocks but 1 enable */
1611 PERIPH_CLK("spdif_out", "spdif_out", NULL, 10, 0x108, 100000000, mux_pllaout0_audio2x_pllp_clkm, MUX | DIV_U71),
1612 PERIPH_CLK("spdif_in", "spdif_in", NULL, 10, 0x10c, 100000000, mux_pllp_pllc_pllm, MUX | DIV_U71),
1613 PERIPH_CLK("pwm", "pwm", NULL, 17, 0x110, 432000000, mux_pllp_pllc_audio_clkm_clk32, MUX | DIV_U71),
1614 PERIPH_CLK("spi", "spi", NULL, 43, 0x114, 40000000, mux_pllp_pllc_pllm_clkm, MUX | DIV_U71),
1615 PERIPH_CLK("xio", "xio", NULL, 45, 0x120, 150000000, mux_pllp_pllc_pllm_clkm, MUX | DIV_U71),
1616 PERIPH_CLK("twc", "twc", NULL, 16, 0x12c, 150000000, mux_pllp_pllc_pllm_clkm, MUX | DIV_U71),
1617 PERIPH_CLK("sbc1", "spi_tegra.0", NULL, 41, 0x134, 160000000, mux_pllp_pllc_pllm_clkm, MUX | DIV_U71),
1618 PERIPH_CLK("sbc2", "spi_tegra.1", NULL, 44, 0x118, 160000000, mux_pllp_pllc_pllm_clkm, MUX | DIV_U71),
1619 PERIPH_CLK("sbc3", "spi_tegra.2", NULL, 46, 0x11c, 160000000, mux_pllp_pllc_pllm_clkm, MUX | DIV_U71),
1620 PERIPH_CLK("sbc4", "spi_tegra.3", NULL, 68, 0x1b4, 160000000, mux_pllp_pllc_pllm_clkm, MUX | DIV_U71),
1621 PERIPH_CLK("ide", "ide", NULL, 25, 0x144, 100000000, mux_pllp_pllc_pllm_clkm, MUX | DIV_U71), /* requires min voltage */
1622 PERIPH_CLK("ndflash", "tegra_nand", NULL, 13, 0x160, 164000000, mux_pllp_pllc_pllm_clkm, MUX | DIV_U71), /* scales with voltage */
1623 /* FIXME: vfir shares an enable with uartb */
1624 PERIPH_CLK("vfir", "vfir", NULL, 7, 0x168, 72000000, mux_pllp_pllc_pllm_clkm, MUX | DIV_U71),
1625 PERIPH_CLK("sdmmc1", "sdhci-tegra.0", NULL, 14, 0x150, 52000000, mux_pllp_pllc_pllm_clkm, MUX | DIV_U71), /* scales with voltage */
1626 PERIPH_CLK("sdmmc2", "sdhci-tegra.1", NULL, 9, 0x154, 52000000, mux_pllp_pllc_pllm_clkm, MUX | DIV_U71), /* scales with voltage */
1627 PERIPH_CLK("sdmmc3", "sdhci-tegra.2", NULL, 69, 0x1bc, 52000000, mux_pllp_pllc_pllm_clkm, MUX | DIV_U71), /* scales with voltage */
1628 PERIPH_CLK("sdmmc4", "sdhci-tegra.3", NULL, 15, 0x160, 52000000, mux_pllp_pllc_pllm_clkm, MUX | DIV_U71), /* scales with voltage */
1629 PERIPH_CLK("vde", "vde", NULL, 61, 0x1c8, 250000000, mux_pllp_pllc_pllm_clkm, MUX | DIV_U71), /* scales with voltage and process_id */
1630 PERIPH_CLK("csite", "csite", NULL, 73, 0x1d4, 144000000, mux_pllp_pllc_pllm_clkm, MUX | DIV_U71), /* max rate ??? */
1631 /* FIXME: what is la? */
1632 PERIPH_CLK("la", "la", NULL, 76, 0x1f8, 26000000, mux_pllp_pllc_pllm_clkm, MUX | DIV_U71),
1633 PERIPH_CLK("owr", "tegra_w1", NULL, 71, 0x1cc, 26000000, mux_pllp_pllc_pllm_clkm, MUX | DIV_U71),
1634 PERIPH_CLK("nor", "nor", NULL, 42, 0x1d0, 92000000, mux_pllp_pllc_pllm_clkm, MUX | DIV_U71), /* requires min voltage */
1635 PERIPH_CLK("mipi", "mipi", NULL, 50, 0x174, 60000000, mux_pllp_pllc_pllm_clkm, MUX | DIV_U71), /* scales with voltage */
1636 PERIPH_CLK("i2c1", "tegra-i2c.0", NULL, 12, 0x124, 26000000, mux_pllp_pllc_pllm_clkm, MUX | DIV_U16),
1637 PERIPH_CLK("i2c2", "tegra-i2c.1", NULL, 54, 0x198, 26000000, mux_pllp_pllc_pllm_clkm, MUX | DIV_U16),
1638 PERIPH_CLK("i2c3", "tegra-i2c.2", NULL, 67, 0x1b8, 26000000, mux_pllp_pllc_pllm_clkm, MUX | DIV_U16),
1639 PERIPH_CLK("dvc", "tegra-i2c.3", NULL, 47, 0x128, 26000000, mux_pllp_pllc_pllm_clkm, MUX | DIV_U16),
1640 PERIPH_CLK("i2c1_i2c", "tegra-i2c.0", "i2c", 0, 0, 72000000, mux_pllp_out3, 0),
1641 PERIPH_CLK("i2c2_i2c", "tegra-i2c.1", "i2c", 0, 0, 72000000, mux_pllp_out3, 0),
1642 PERIPH_CLK("i2c3_i2c", "tegra-i2c.2", "i2c", 0, 0, 72000000, mux_pllp_out3, 0),
1643 PERIPH_CLK("dvc_i2c", "tegra-i2c.3", "i2c", 0, 0, 72000000, mux_pllp_out3, 0),
1644 PERIPH_CLK("uarta", "uart.0", NULL, 6, 0x178, 216000000, mux_pllp_pllc_pllm_clkm, MUX),
1645 PERIPH_CLK("uartb", "uart.1", NULL, 7, 0x17c, 216000000, mux_pllp_pllc_pllm_clkm, MUX),
1646 PERIPH_CLK("uartc", "uart.2", NULL, 55, 0x1a0, 216000000, mux_pllp_pllc_pllm_clkm, MUX),
1647 PERIPH_CLK("uartd", "uart.3", NULL, 65, 0x1c0, 216000000, mux_pllp_pllc_pllm_clkm, MUX),
1648 PERIPH_CLK("uarte", "uart.4", NULL, 66, 0x1c4, 216000000, mux_pllp_pllc_pllm_clkm, MUX),
1649 PERIPH_CLK("3d", "3d", NULL, 24, 0x158, 300000000, mux_pllm_pllc_pllp_plla, MUX | DIV_U71 | PERIPH_MANUAL_RESET), /* scales with voltage and process_id */
1650 PERIPH_CLK("2d", "2d", NULL, 21, 0x15c, 300000000, mux_pllm_pllc_pllp_plla, MUX | DIV_U71), /* scales with voltage and process_id */
1651 /* FIXME: vi and vi_sensor share an enable */
1652 PERIPH_CLK("vi", "vi", NULL, 20, 0x148, 150000000, mux_pllm_pllc_pllp_plla, MUX | DIV_U71), /* scales with voltage and process_id */
1653 PERIPH_CLK("vi_sensor", "vi_sensor", NULL, 20, 0x1a8, 150000000, mux_pllm_pllc_pllp_plla, MUX | DIV_U71 | PERIPH_NO_RESET), /* scales with voltage and process_id */
1654 PERIPH_CLK("epp", "epp", NULL, 19, 0x16c, 300000000, mux_pllm_pllc_pllp_plla, MUX | DIV_U71), /* scales with voltage and process_id */
1655 PERIPH_CLK("mpe", "mpe", NULL, 60, 0x170, 250000000, mux_pllm_pllc_pllp_plla, MUX | DIV_U71), /* scales with voltage and process_id */
1656 PERIPH_CLK("host1x", "host1x", NULL, 28, 0x180, 166000000, mux_pllm_pllc_pllp_plla, MUX | DIV_U71), /* scales with voltage and process_id */
1657 /* FIXME: cve and tvo share an enable */
1658 PERIPH_CLK("cve", "cve", NULL, 49, 0x140, 250000000, mux_pllp_plld_pllc_clkm, MUX | DIV_U71), /* requires min voltage */
1659 PERIPH_CLK("tvo", "tvo", NULL, 49, 0x188, 250000000, mux_pllp_plld_pllc_clkm, MUX | DIV_U71), /* requires min voltage */
1660 PERIPH_CLK("hdmi", "hdmi", NULL, 51, 0x18c, 148500000, mux_pllp_plld_pllc_clkm, MUX | DIV_U71), /* requires min voltage */
1661 PERIPH_CLK("tvdac", "tvdac", NULL, 53, 0x194, 250000000, mux_pllp_plld_pllc_clkm, MUX | DIV_U71), /* requires min voltage */
1662 PERIPH_CLK("disp1", "tegrafb.0", NULL, 27, 0x138, 190000000, mux_pllp_plld_pllc_clkm, MUX | DIV_U71), /* scales with voltage and process_id */
1663 PERIPH_CLK("disp2", "tegrafb.1", NULL, 26, 0x13c, 190000000, mux_pllp_plld_pllc_clkm, MUX | DIV_U71), /* scales with voltage and process_id */
1664 PERIPH_CLK("usbd", "fsl-tegra-udc", NULL, 22, 0, 480000000, mux_clk_m, 0), /* requires min voltage */
1665 PERIPH_CLK("usb2", "tegra-ehci.1", NULL, 58, 0, 480000000, mux_clk_m, 0), /* requires min voltage */
1666 PERIPH_CLK("usb3", "tegra-ehci.2", NULL, 59, 0, 480000000, mux_clk_m, 0), /* requires min voltage */
1667 PERIPH_CLK("emc", "emc", NULL, 57, 0x19c, 800000000, mux_pllm_pllc_pllp_clkm, MUX | DIV_U71 | PERIPH_EMC_ENB),
1668 PERIPH_CLK("dsi", "dsi", NULL, 48, 0, 500000000, mux_plld, 0), /* scales with voltage */
1669 PERIPH_CLK("csi", "csi", NULL, 52, 0, 72000000, mux_pllp_out3, 0),
1670 PERIPH_CLK("isp", "isp", NULL, 23, 0, 150000000, mux_clk_m, 0), /* same frequency as VI */
1671 PERIPH_CLK("csus", "csus", NULL, 92, 0, 150000000, mux_clk_m, PERIPH_NO_RESET),
1672 PERIPH_CLK("pex", NULL, "pex", 70, 0, 26000000, mux_clk_m, PERIPH_MANUAL_RESET),
1673 PERIPH_CLK("afi", NULL, "afi", 72, 0, 26000000, mux_clk_m, PERIPH_MANUAL_RESET),
1674 PERIPH_CLK("pcie_xclk", NULL, "pcie_xclk", 74, 0, 26000000, mux_clk_m, PERIPH_MANUAL_RESET),
1675 };
1676
1677 #define CLK_DUPLICATE(_name, _dev, _con) \
1678 { \
1679 .name = _name, \
1680 .lookup = { \
1681 .dev_id = _dev, \
1682 .con_id = _con, \
1683 }, \
1684 }
1685
1686 /* Some clocks may be used by different drivers depending on the board
1687 * configuration. List those here to register them twice in the clock lookup
1688 * table under two names.
1689 */
1690 struct clk_duplicate tegra_clk_duplicates[] = {
1691 CLK_DUPLICATE("uarta", "tegra_uart.0", NULL),
1692 CLK_DUPLICATE("uartb", "tegra_uart.1", NULL),
1693 CLK_DUPLICATE("uartc", "tegra_uart.2", NULL),
1694 CLK_DUPLICATE("uartd", "tegra_uart.3", NULL),
1695 CLK_DUPLICATE("uarte", "tegra_uart.4", NULL),
1696 CLK_DUPLICATE("host1x", "tegrafb.0", "host1x"),
1697 CLK_DUPLICATE("host1x", "tegrafb.1", "host1x"),
1698 CLK_DUPLICATE("usbd", "tegra-ehci.0", NULL),
1699 };
1700
1701 #define CLK(dev, con, ck) \
1702 { \
1703 .dev_id = dev, \
1704 .con_id = con, \
1705 .clk = ck, \
1706 }
1707
1708 struct clk_lookup tegra_clk_lookups[] = {
1709 /* external root sources */
1710 CLK(NULL, "32k_clk", &tegra_clk_32k),
1711 CLK(NULL, "pll_s", &tegra_pll_s),
1712 CLK(NULL, "clk_m", &tegra_clk_m),
1713 CLK(NULL, "pll_m", &tegra_pll_m),
1714 CLK(NULL, "pll_m_out1", &tegra_pll_m_out1),
1715 CLK(NULL, "pll_c", &tegra_pll_c),
1716 CLK(NULL, "pll_c_out1", &tegra_pll_c_out1),
1717 CLK(NULL, "pll_p", &tegra_pll_p),
1718 CLK(NULL, "pll_p_out1", &tegra_pll_p_out1),
1719 CLK(NULL, "pll_p_out2", &tegra_pll_p_out2),
1720 CLK(NULL, "pll_p_out3", &tegra_pll_p_out3),
1721 CLK(NULL, "pll_p_out4", &tegra_pll_p_out4),
1722 CLK(NULL, "pll_a", &tegra_pll_a),
1723 CLK(NULL, "pll_a_out0", &tegra_pll_a_out0),
1724 CLK(NULL, "pll_d", &tegra_pll_d),
1725 CLK(NULL, "pll_d_out0", &tegra_pll_d_out0),
1726 CLK(NULL, "pll_u", &tegra_pll_u),
1727 CLK(NULL, "pll_x", &tegra_pll_x),
1728 CLK(NULL, "pll_e", &tegra_pll_e),
1729 CLK(NULL, "cclk", &tegra_clk_cclk),
1730 CLK(NULL, "sclk", &tegra_clk_sclk),
1731 CLK(NULL, "hclk", &tegra_clk_hclk),
1732 CLK(NULL, "pclk", &tegra_clk_pclk),
1733 CLK(NULL, "clk_d", &tegra_clk_d),
1734 CLK(NULL, "cpu", &tegra_clk_virtual_cpu),
1735 };
1736
1737 void __init tegra2_init_clocks(void)
1738 {
1739 int i;
1740 struct clk_lookup *cl;
1741 struct clk *c;
1742 struct clk_duplicate *cd;
1743
1744 for (i = 0; i < ARRAY_SIZE(tegra_clk_lookups); i++) {
1745 cl = &tegra_clk_lookups[i];
1746 clk_init(cl->clk);
1747 clkdev_add(cl);
1748 }
1749
1750 for (i = 0; i < ARRAY_SIZE(tegra_periph_clks); i++) {
1751 c = &tegra_periph_clks[i];
1752 cl = &c->lookup;
1753 cl->clk = c;
1754
1755 clk_init(cl->clk);
1756 clkdev_add(cl);
1757 }
1758
1759 for (i = 0; i < ARRAY_SIZE(tegra_clk_duplicates); i++) {
1760 cd = &tegra_clk_duplicates[i];
1761 c = tegra_get_clock_by_name(cd->name);
1762 if (c) {
1763 cl = &cd->lookup;
1764 cl->clk = c;
1765 clkdev_add(cl);
1766 } else {
1767 pr_err("%s: Unknown duplicate clock %s\n", __func__,
1768 cd->name);
1769 }
1770 }
1771
1772 init_audio_sync_clock_mux();
1773 }
1774
1775 #ifdef CONFIG_PM
1776 static u32 clk_rst_suspend[RST_DEVICES_NUM + CLK_OUT_ENB_NUM +
1777 PERIPH_CLK_SOURCE_NUM + 3];
1778
1779 void tegra_clk_suspend(void)
1780 {
1781 unsigned long off, i;
1782 u32 *ctx = clk_rst_suspend;
1783
1784 *ctx++ = clk_readl(OSC_CTRL) & OSC_CTRL_MASK;
1785
1786 for (off = PERIPH_CLK_SOURCE_I2S1; off <= PERIPH_CLK_SOURCE_OSC;
1787 off += 4) {
1788 if (off == PERIPH_CLK_SOURCE_EMC)
1789 continue;
1790 *ctx++ = clk_readl(off);
1791 }
1792
1793 off = RST_DEVICES;
1794 for (i = 0; i < RST_DEVICES_NUM; i++, off += 4)
1795 *ctx++ = clk_readl(off);
1796
1797 off = CLK_OUT_ENB;
1798 for (i = 0; i < CLK_OUT_ENB_NUM; i++, off += 4)
1799 *ctx++ = clk_readl(off);
1800
1801 *ctx++ = clk_readl(MISC_CLK_ENB);
1802 *ctx++ = clk_readl(CLK_MASK_ARM);
1803 }
1804
1805 void tegra_clk_resume(void)
1806 {
1807 unsigned long off, i;
1808 const u32 *ctx = clk_rst_suspend;
1809 u32 val;
1810
1811 val = clk_readl(OSC_CTRL) & ~OSC_CTRL_MASK;
1812 val |= *ctx++;
1813 clk_writel(val, OSC_CTRL);
1814
1815 /* enable all clocks before configuring clock sources */
1816 clk_writel(0xbffffff9ul, CLK_OUT_ENB);
1817 clk_writel(0xfefffff7ul, CLK_OUT_ENB + 4);
1818 clk_writel(0x77f01bfful, CLK_OUT_ENB + 8);
1819 wmb();
1820
1821 for (off = PERIPH_CLK_SOURCE_I2S1; off <= PERIPH_CLK_SOURCE_OSC;
1822 off += 4) {
1823 if (off == PERIPH_CLK_SOURCE_EMC)
1824 continue;
1825 clk_writel(*ctx++, off);
1826 }
1827 wmb();
1828
1829 off = RST_DEVICES;
1830 for (i = 0; i < RST_DEVICES_NUM; i++, off += 4)
1831 clk_writel(*ctx++, off);
1832 wmb();
1833
1834 off = CLK_OUT_ENB;
1835 for (i = 0; i < CLK_OUT_ENB_NUM; i++, off += 4)
1836 clk_writel(*ctx++, off);
1837 wmb();
1838
1839 clk_writel(*ctx++, MISC_CLK_ENB);
1840 clk_writel(*ctx++, CLK_MASK_ARM);
1841 }
1842 #endif
Linux with added FPC-III support