Merge commit 'main-jb-2012.08.03-B4' into t114-0806
[linux-2.6.git] / arch / arm / mach-tegra / timer.c
1 /*
2  * arch/arch/mach-tegra/timer.c
3  *
4  * Copyright (C) 2010 Google, Inc.
5  *
6  * Author:
7  *      Colin Cross <ccross@google.com>
8  *
9  * Copyright (C) 2010-2012 NVIDIA Corporation.
10  *
11  * This software is licensed under the terms of the GNU General Public
12  * License version 2, as published by the Free Software Foundation, and
13  * may be copied, distributed, and modified under those terms.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  */
21
22 #include <linux/init.h>
23 #include <linux/err.h>
24 #include <linux/time.h>
25 #include <linux/interrupt.h>
26 #include <linux/irq.h>
27 #include <linux/clockchips.h>
28 #include <linux/clocksource.h>
29 #include <linux/clk.h>
30 #include <linux/cpu.h>
31 #include <linux/io.h>
32 #include <linux/syscore_ops.h>
33 #include <linux/cpu_pm.h>
34 #include <linux/rtc.h>
35
36 #include <asm/mach/time.h>
37 #include <asm/arch_timer.h>
38 #include <asm/cputype.h>
39 #include <asm/smp_twd.h>
40 #include <asm/system.h>
41 #include <asm/sched_clock.h>
42
43 #include <mach/iomap.h>
44 #include <mach/io.h>
45 #include <mach/irqs.h>
46 #include <mach/hardware.h>
47
48 #include "board.h"
49 #include "clock.h"
50 #include "timer.h"
51 #include "fuse.h"
52
53 extern int __init arch_timer_register(struct arch_timer *at);
54
55 static void __iomem *timer_reg_base = IO_ADDRESS(TEGRA_TMR1_BASE);
56 static void __iomem *rtc_base = IO_ADDRESS(TEGRA_RTC_BASE);
57
58 static struct timespec persistent_ts;
59 static u64 persistent_ms, last_persistent_ms;
60 static u32 usec_config;
61 static u32 usec_offset;
62 static bool usec_suspended;
63
64 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
65 static u32 system_timer = (TEGRA_TMR3_BASE - TEGRA_TMR1_BASE);
66 #else
67 static u32 system_timer = 0;
68 #endif
69
70 #define timer_writel(value, reg) \
71         __raw_writel(value, timer_reg_base + (reg))
72 #define timer_readl(reg) \
73         __raw_readl(timer_reg_base + (reg))
74
75 static int tegra_timer_set_next_event(unsigned long cycles,
76                                          struct clock_event_device *evt)
77 {
78         u32 reg;
79
80         reg = 0x80000000 | ((cycles > 1) ? (cycles-1) : 0);
81         timer_writel(reg, system_timer + TIMER_PTV);
82
83         return 0;
84 }
85
86 static void tegra_timer_set_mode(enum clock_event_mode mode,
87                                     struct clock_event_device *evt)
88 {
89         u32 reg;
90
91         timer_writel(0, system_timer + TIMER_PTV);
92
93         switch (mode) {
94         case CLOCK_EVT_MODE_PERIODIC:
95                 reg = 0xC0000000 | ((1000000/HZ)-1);
96                 timer_writel(reg, system_timer + TIMER_PTV);
97                 break;
98         case CLOCK_EVT_MODE_ONESHOT:
99                 break;
100         case CLOCK_EVT_MODE_UNUSED:
101         case CLOCK_EVT_MODE_SHUTDOWN:
102         case CLOCK_EVT_MODE_RESUME:
103                 break;
104         }
105 }
106
107 static struct clock_event_device tegra_clockevent = {
108         .name           = "timer0",
109         .rating         = 300,
110         .features       = CLOCK_EVT_FEAT_ONESHOT | CLOCK_EVT_FEAT_PERIODIC,
111         .set_next_event = tegra_timer_set_next_event,
112         .set_mode       = tegra_timer_set_mode,
113 };
114
115 static u32 notrace tegra_read_usec(void)
116 {
117         u32 cyc = usec_offset;
118         if (!usec_suspended)
119                 cyc += timer_readl(TIMERUS_CNTR_1US);
120         return cyc;
121 }
122
123 static u32 notrace tegra_read_sched_clock(void)
124 {
125         return tegra_read_usec();
126 }
127
128 /*
129  * tegra_rtc_read - Reads the Tegra RTC registers
130  * Care must be taken that this funciton is not called while the
131  * tegra_rtc driver could be executing to avoid race conditions
132  * on the RTC shadow register
133  */
134 static u64 tegra_rtc_read_ms(void)
135 {
136         u32 ms = readl(rtc_base + RTC_MILLISECONDS);
137         u32 s = readl(rtc_base + RTC_SHADOW_SECONDS);
138         return (u64)s * MSEC_PER_SEC + ms;
139 }
140
141 /*
142  * read_persistent_clock -  Return time from a persistent clock.
143  *
144  * Reads the time from a source which isn't disabled during PM, the
145  * 32k sync timer.  Convert the cycles elapsed since last read into
146  * nsecs and adds to a monotonically increasing timespec.
147  * Care must be taken that this funciton is not called while the
148  * tegra_rtc driver could be executing to avoid race conditions
149  * on the RTC shadow register
150  */
151 void read_persistent_clock(struct timespec *ts)
152 {
153         u64 delta;
154         struct timespec *tsp = &persistent_ts;
155
156         last_persistent_ms = persistent_ms;
157         persistent_ms = tegra_rtc_read_ms();
158         delta = persistent_ms - last_persistent_ms;
159
160         timespec_add_ns(tsp, delta * NSEC_PER_MSEC);
161         *ts = *tsp;
162 }
163
164 static irqreturn_t tegra_timer_interrupt(int irq, void *dev_id)
165 {
166         struct clock_event_device *evt = (struct clock_event_device *)dev_id;
167         timer_writel(1<<30, system_timer + TIMER_PCR);
168         evt->event_handler(evt);
169         return IRQ_HANDLED;
170 }
171
172 static struct irqaction tegra_timer_irq = {
173         .name           = "timer0",
174         .flags          = IRQF_DISABLED | IRQF_TIMER | IRQF_TRIGGER_HIGH,
175         .handler        = tegra_timer_interrupt,
176         .dev_id         = &tegra_clockevent,
177 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
178         .irq            = INT_TMR3,
179 #else
180         .irq            = INT_TMR1,
181 #endif
182 };
183
184 static int tegra_timer_suspend(void)
185 {
186         usec_config = timer_readl(TIMERUS_USEC_CFG);
187
188         usec_offset += timer_readl(TIMERUS_CNTR_1US);
189         usec_suspended = true;
190
191         return 0;
192 }
193
194 static void tegra_timer_resume(void)
195 {
196         timer_writel(usec_config, TIMERUS_USEC_CFG);
197
198         usec_offset -= timer_readl(TIMERUS_CNTR_1US);
199         usec_suspended = false;
200 }
201
202 static struct syscore_ops tegra_timer_syscore_ops = {
203         .suspend = tegra_timer_suspend,
204         .resume = tegra_timer_resume,
205 };
206
207 #ifdef CONFIG_HAVE_ARM_TWD
208 static DEFINE_TWD_LOCAL_TIMER(twd_local_timer,
209                               TEGRA_ARM_PERIF_BASE + 0x600,
210                               IRQ_LOCALTIMER);
211 static void __iomem *tegra_twd_base = IO_ADDRESS(TEGRA_ARM_PERIF_BASE + 0x600);
212
213 void __init tegra_cpu_timer_init(void)
214 {
215         struct clk *cpu, *twd_clk;
216         int err;
217
218         /* The twd clock is a detached child of the CPU complex clock.
219            Force an update of the twd clock after DVFS has updated the
220            CPU clock rate. */
221
222         twd_clk = tegra_get_clock_by_name("twd");
223         BUG_ON(!twd_clk);
224         cpu = tegra_get_clock_by_name("cpu");
225         err = clk_set_rate(twd_clk, clk_get_rate(cpu));
226
227         if (err)
228                 pr_err("Failed to set twd clock rate: %d\n", err);
229         else
230                 pr_debug("TWD clock rate: %ld\n", clk_get_rate(twd_clk));
231 }
232
233 int tegra_twd_get_state(struct tegra_twd_context *context)
234 {
235         context->twd_ctrl = readl(tegra_twd_base + TWD_TIMER_CONTROL);
236         context->twd_load = readl(tegra_twd_base + TWD_TIMER_LOAD);
237         context->twd_cnt = readl(tegra_twd_base + TWD_TIMER_COUNTER);
238
239         return 0;
240 }
241
242 void tegra_twd_suspend(struct tegra_twd_context *context)
243 {
244         context->twd_ctrl = readl(tegra_twd_base + TWD_TIMER_CONTROL);
245         context->twd_load = readl(tegra_twd_base + TWD_TIMER_LOAD);
246         if ((context->twd_load == 0) &&
247             (context->twd_ctrl & TWD_TIMER_CONTROL_PERIODIC) &&
248             (context->twd_ctrl & (TWD_TIMER_CONTROL_ENABLE |
249                                   TWD_TIMER_CONTROL_IT_ENABLE))) {
250                 WARN("%s: TWD enabled but counter was 0\n", __func__);
251                 context->twd_load = 1;
252         }
253         __raw_writel(0, tegra_twd_base + TWD_TIMER_CONTROL);
254 }
255
256 void tegra_twd_resume(struct tegra_twd_context *context)
257 {
258         BUG_ON((context->twd_load == 0) &&
259                (context->twd_ctrl & TWD_TIMER_CONTROL_PERIODIC) &&
260                (context->twd_ctrl & (TWD_TIMER_CONTROL_ENABLE |
261                                      TWD_TIMER_CONTROL_IT_ENABLE)));
262         writel(context->twd_load, tegra_twd_base + TWD_TIMER_LOAD);
263         writel(context->twd_ctrl, tegra_twd_base + TWD_TIMER_CONTROL);
264 }
265
266 static void __init tegra_init_late_timer(void)
267 {
268         int err = twd_local_timer_register(&twd_local_timer);
269         if (err)
270                 pr_err("twd_timer_register failed %d\n", err);
271 }
272 #else
273 #define tegra_twd_get_state     do {} while(0)
274 #define tegra_twd_suspend       do {} while(0)
275 #define tegra_twd_resume        do {} while(0)
276 #endif
277
278 #ifdef CONFIG_ARM_ARCH_TIMER
279 int arch_timer_get_state(struct arch_timer_context *context)
280 {
281         u32 val;
282
283         asm volatile("mrc p15, 0, %0, c14, c2, 0" : "=r" (val));
284         context->cntp_tval = val;
285         asm volatile("mrc p15, 0, %0, c14, c2, 1" : "=r" (val));
286         context->cntp_ctl = val;
287         asm volatile("mrc p15, 0, %0, c14, c0, 0" : "=r" (val));
288         context->cntfrq = val;
289         return 0;
290 }
291
292 void arch_timer_suspend(struct arch_timer_context *context)
293 {
294         u32 val;
295
296         asm volatile("mrc p15, 0, %0, c14, c2, 0" : "=r" (val));
297         context->cntp_tval = val;
298         asm volatile("mrc p15, 0, %0, c14, c2, 1" : "=r" (val));
299         context->cntp_ctl = val;
300 }
301
302 void arch_timer_resume(struct arch_timer_context *context)
303 {
304         u32 val;
305
306         val = context->cntp_tval;
307         asm volatile("mcr p15, 0, %0, c14, c2, 0" : : "r"(val));
308         val = context->cntp_ctl;
309         asm volatile("mcr p15, 0, %0, c14, c2, 1" : : "r"(val));
310 }
311 #else
312 #define arch_timer_get_state do {} while(0)
313 #define arch_timer_suspend do {} while(0)
314 #define arch_timer_resume do {} while(0)
315 #endif
316
317 #ifdef CONFIG_ARM_ARCH_TIMER
318
319 /* Time Stamp Counter (TSC) base address */
320 static void __iomem *tsc = IO_ADDRESS(TEGRA_TSC_BASE);
321 static bool arch_timer_initialized;
322
323 #define TSC_CNTCR               0               /* TSC control registers */
324 #define TSC_CNTCR_ENABLE        (1 << 0)        /* Enable*/
325 #define TSC_CNTCR_HDBG          (1 << 1)        /* Halt on debug */
326
327 #define TSC_CNTCV0              0x8             /* TSC counter (LSW) */
328 #define TSC_CNTCV1              0xC             /* TSC counter (MSW) */
329 #define TSC_CNTFID0             0x20            /* TSC freq id 0 */
330
331 #define tsc_writel(value, reg) \
332         __raw_writel(value, (u32)tsc + (reg))
333 #define tsc_readl(reg) \
334         __raw_readl((u32)tsc + (reg))
335
336
337 /* Is the optional system timer available? */
338 static int local_timer_is_architected(void)
339 {
340 #ifdef CONFIG_TEGRA_SIMULATION_PLATFORM
341         /* HACK: The simulator does not yet support arch timers. */
342         return 0;
343 #else
344         return (cpu_architecture() >= CPU_ARCH_ARMv7) &&
345                ((read_cpuid_ext(CPUID_EXT_PFR1) >> 16) & 0xf) == 1;
346 #endif
347 }
348
349 void __init tegra_cpu_timer_init(void)
350 {
351         u32 tsc_ref_freq;
352         u32 reg;
353
354         if (!local_timer_is_architected())
355                 return;
356
357         tsc_ref_freq = tegra_clk_measure_input_freq();
358         if (tsc_ref_freq == 115200 || tsc_ref_freq == 230400) {
359                 /*
360                  * OSC detection function will bug out if revision is not QT and
361                  * the detected frequency is one of these two.
362                  */
363                 tsc_ref_freq = 13000000;
364                 pr_info("fake tsc_ref_req=%d in QT\n", tsc_ref_freq);
365         }
366
367         /* Set the Timer System Counter (TSC) reference frequency
368            NOTE: this is a write once register */
369         tsc_writel(tsc_ref_freq, TSC_CNTFID0);
370
371         /* Program CNTFRQ to the same value.
372            NOTE: this is a write once (per CPU reset) register. */
373         __asm__("mcr p15, 0, %0, c14, c0, 0\n" : : "r" (tsc_ref_freq));
374
375         /* CNTFRQ must agree with the TSC reference frequency. */
376         __asm__("mrc p15, 0, %0, c14, c0, 0\n" : "=r" (reg));
377         BUG_ON(reg != tsc_ref_freq);
378
379         /* Enable the TSC. */
380         reg = tsc_readl(TSC_CNTCR);
381         reg |= TSC_CNTCR_ENABLE | TSC_CNTCR_HDBG;
382         tsc_writel(reg, TSC_CNTCR);
383 }
384
385 static void tegra_arch_timer_per_cpu_init(void)
386 {
387         if (arch_timer_initialized) {
388                 u32 tsc_ref_freq = tegra_clk_measure_input_freq();
389
390                 /*
391                  * OSC detection function will bug out if revision is not QT and
392                  * the detected frequency is one of these two.
393                  */
394                 if (tsc_ref_freq == 115200 || tsc_ref_freq == 230400)
395                         tsc_ref_freq = 13000000;
396
397                 /* Program CNTFRQ to the input frequency.
398                    NOTE: this is a write once (per CPU reset) register. */
399                 __asm__("mcr p15, 0, %0, c14, c0, 0\n" : : "r" (tsc_ref_freq));
400         }
401 }
402
403 static int arch_timer_cpu_notify(struct notifier_block *self,
404                                     unsigned long action, void *data)
405 {
406         switch (action) {
407         case CPU_STARTING:
408         case CPU_STARTING_FROZEN:
409                 tegra_arch_timer_per_cpu_init();
410                 break;
411         default:
412                 break;
413         }
414
415         return NOTIFY_OK;
416 }
417
418 static struct notifier_block arch_timer_cpu_nb = {
419         .notifier_call = arch_timer_cpu_notify,
420 };
421
422 static int arch_timer_cpu_pm_notify(struct notifier_block *self,
423                                     unsigned long action, void *data)
424 {
425         switch (action) {
426         case CPU_PM_EXIT:
427                 tegra_arch_timer_per_cpu_init();
428                 break;
429                 break;
430         }
431
432         return NOTIFY_OK;
433 }
434
435 static struct notifier_block arch_timer_cpu_pm_nb = {
436         .notifier_call = arch_timer_cpu_pm_notify,
437 };
438
439 static int __init tegra_init_arch_timer(void)
440 {
441         int err;
442
443         if (!local_timer_is_architected())
444                 return -ENODEV;
445
446         err = arch_timer_sched_clock_init();
447         if (err) {
448                 pr_err("%s: Unable to initialize arch timer sched_clock: %d\n",
449                      __func__, err);
450                 return err;
451         }
452
453         register_cpu_notifier(&arch_timer_cpu_nb);
454         cpu_pm_register_notifier(&arch_timer_cpu_pm_nb);
455         arch_timer_initialized = true;
456         return 0;
457 }
458
459 static struct arch_timer tegra_arch_timer = {
460         .res[0] = {
461                 .start  = 29,
462                 .end    = 29,
463                 .flags  = IORESOURCE_IRQ,
464         },
465         .res[1] = {
466                 .start  = 30,
467                 .end    = 30,
468                 .flags  = IORESOURCE_IRQ,
469         },
470 };
471
472 static void __init tegra_init_late_timer(void)
473 {
474         int err = -ENODEV;
475
476         if (arch_timer_initialized) {
477                 err = arch_timer_register(&tegra_arch_timer);
478                 if (err)
479                         pr_err("%s: Unable to register arch timer: %d\n",
480                              __func__, err);
481         }
482 }
483
484 #ifdef CONFIG_PM_SLEEP
485
486 static void __iomem *pmc = IO_ADDRESS(TEGRA_PMC_BASE);
487 static u32 tsc_suspend_start;
488 static u32 tsc_resume_start;
489
490 #define pmc_writel(value, reg) \
491                 writel(value, (u32)pmc + (reg))
492 #define pmc_readl(reg) \
493                 readl((u32)pmc + (reg))
494
495 #define PMC_DPD_ENABLE                  0x24
496 #define PMC_DPD_ENABLE_TSC_MULT_ENABLE  (1 << 1)
497
498 #define PMC_TSC_MULT                    0x2b4
499 #define PMC_TSC_MULT_FREQ_STS           (1 << 16)
500
501 #define TSC_TIMEOUT_US                  32
502
503 void tegra_tsc_suspend(void)
504 {
505         if (arch_timer_initialized) {
506                 u32 reg = pmc_readl(PMC_DPD_ENABLE);
507                 BUG_ON(reg & PMC_DPD_ENABLE_TSC_MULT_ENABLE);
508                 reg |= PMC_DPD_ENABLE_TSC_MULT_ENABLE;
509                 pmc_writel(reg, PMC_DPD_ENABLE);
510                 tsc_suspend_start = timer_readl(TIMERUS_CNTR_1US);
511         }
512 }
513
514 void tegra_tsc_resume(void)
515 {
516         if (arch_timer_initialized) {
517                 u32 reg = pmc_readl(PMC_DPD_ENABLE);
518                 BUG_ON(!(reg & PMC_DPD_ENABLE_TSC_MULT_ENABLE));
519                 reg &= ~PMC_DPD_ENABLE_TSC_MULT_ENABLE;
520                 pmc_writel(reg, PMC_DPD_ENABLE);
521                 tsc_resume_start = timer_readl(TIMERUS_CNTR_1US);
522         }
523 }
524
525 void tegra_tsc_wait_for_suspend(void)
526 {
527         if (arch_timer_initialized) {
528                 while ((timer_readl(TIMERUS_CNTR_1US) - tsc_suspend_start) <
529                         TSC_TIMEOUT_US) {
530                         if (pmc_readl(PMC_TSC_MULT) & PMC_TSC_MULT_FREQ_STS)
531                                 break;
532                         cpu_relax();
533                 }
534         }
535 }
536
537 void tegra_tsc_wait_for_resume(void)
538 {
539         if (arch_timer_initialized) {
540                 while ((timer_readl(TIMERUS_CNTR_1US) - tsc_resume_start) <
541                         TSC_TIMEOUT_US) {
542                         if (!(pmc_readl(PMC_TSC_MULT) & PMC_TSC_MULT_FREQ_STS))
543                                 break;
544                         cpu_relax();
545                 }
546         }
547 }
548
549 #endif
550
551 #else
552 static inline int tegra_init_arch_timer(void) { return -ENODEV; }
553 static inline int tegra_init_late_arch_timer(void) { return -ENODEV; }
554 #endif
555
556 #ifdef CONFIG_RTC_CLASS
557 /**
558  * has_readtime - check rtc device has readtime ability
559  * @dev: current device
560  * @name_ptr: name to be returned
561  *
562  * This helper function checks to see if the rtc device can be
563  * used for reading time
564  */
565 static int has_readtime(struct device *dev, void *name_ptr)
566 {
567         struct rtc_device *candidate = to_rtc_device(dev);
568
569         if (!candidate->ops->read_time)
570                 return 0;
571
572         return 1;
573 }
574
575 /**
576  * tegra_get_linear_age - helper function to return linear age
577  * from Jan 2012.
578  *
579  * @return
580  * 1 - Jan 2012,
581  * 2 - Feb 2012,
582  * .....
583  * 13 - Jan 2013
584  */
585 int tegra_get_linear_age(void)
586 {
587         struct rtc_time tm;
588         int year, month, linear_age;
589         struct rtc_device *rtc_dev = NULL;
590         const char *name = NULL;
591         int ret;
592         struct device *dev = NULL;
593
594         linear_age = -1;
595         year = month = 0;
596         dev = class_find_device(rtc_class, NULL, &name, has_readtime);
597
598         if (!dev) {
599                 pr_err("DVFS: No device with readtime capability\n");
600                 goto done;
601         }
602
603         name = dev_name(dev);
604
605         pr_info("DVFS: Got RTC device name:%s\n", name);
606
607         if (name)
608                 rtc_dev = rtc_class_open((char *)name);
609
610         if (!rtc_dev) {
611                 pr_err("DVFS: No RTC device\n");
612                 goto error_dev;
613         }
614
615         ret = rtc_read_time(rtc_dev, &tm);
616
617         if (ret < 0) {
618                 pr_err("DVFS: Can't read RTC time\n");
619                 goto error_rtc;
620         }
621
622         year = tm.tm_year;
623         /*Normalize it to 2012*/
624         year -= 112;
625         month = tm.tm_mon + 1;
626
627         if (year >= 0)
628                 linear_age = year * 12 + month;
629
630 error_rtc:
631         rtc_class_close(rtc_dev);
632 error_dev:
633         put_device(dev);
634 done:
635         return linear_age;
636
637 }
638
639 #else
640 int tegra_get_linear_age()
641 {
642         return -1;
643 }
644 #endif
645
646 void __init tegra_init_timer(void)
647 {
648         struct clk *clk;
649         int ret;
650         unsigned long rate;
651
652         clk = clk_get_sys("timer", NULL);
653         if (IS_ERR(clk)) {
654                 pr_warn("Unable to get timer clock."
655                         " Assuming 12Mhz input clock.\n");
656                 rate = 12000000;
657         } else {
658                 clk_enable(clk);
659                 rate = clk_get_rate(clk);
660         }
661
662         /*
663          * rtc registers are used by read_persistent_clock, keep the rtc clock
664          * enabled
665          */
666         clk = clk_get_sys("rtc-tegra", NULL);
667         if (IS_ERR(clk))
668                 pr_warn("Unable to get rtc-tegra clock\n");
669         else
670                 clk_enable(clk);
671
672         switch (rate) {
673         case 12000000:
674                 timer_writel(0x000b, TIMERUS_USEC_CFG);
675                 break;
676         case 13000000:
677                 timer_writel(0x000c, TIMERUS_USEC_CFG);
678                 break;
679         case 19200000:
680                 timer_writel(0x045f, TIMERUS_USEC_CFG);
681                 break;
682         case 26000000:
683                 timer_writel(0x0019, TIMERUS_USEC_CFG);
684                 break;
685 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
686         case 16800000:
687                 timer_writel(0x0453, TIMERUS_USEC_CFG);
688                 break;
689         case 38400000:
690                 timer_writel(0x04BF, TIMERUS_USEC_CFG);
691                 break;
692         case 48000000:
693                 timer_writel(0x002F, TIMERUS_USEC_CFG);
694                 break;
695 #endif
696         default:
697                 if (tegra_revision == TEGRA_REVISION_QT) {
698                         timer_writel(0x000c, TIMERUS_USEC_CFG);
699                         break;
700                 }
701                 WARN(1, "Unknown clock rate");
702         }
703
704 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
705         tegra20_init_timer();
706 #else
707         tegra30_init_timer();
708 #endif
709
710         /* Architectural timers take precedence over broadcast timers.
711            Only register a broadcast clockevent device if architectural
712            timers do not exist or cannot be initialized. */
713         if (tegra_init_arch_timer())
714                 /* Architectural timers do not exist or cannot be initialzied.
715                    Fall back to using the broadcast timer as the sched clock. */
716                 setup_sched_clock(tegra_read_sched_clock, 32, 1000000);
717
718         ret = clocksource_mmio_init(timer_reg_base + TIMERUS_CNTR_1US,
719                 "timer_us", 1000000, 300, 32,
720                 clocksource_mmio_readl_up);
721         if (ret) {
722                 pr_err("%s: Failed to register clocksource: %d\n",
723                         __func__, ret);
724                 BUG();
725         }
726
727         ret = setup_irq(tegra_timer_irq.irq, &tegra_timer_irq);
728         if (ret) {
729                 pr_err("%s: Failed to register timer IRQ: %d\n",
730                         __func__, ret);
731                 BUG();
732         }
733
734         clockevents_calc_mult_shift(&tegra_clockevent, 1000000, 5);
735         tegra_clockevent.max_delta_ns =
736                 clockevent_delta2ns(0x1fffffff, &tegra_clockevent);
737         tegra_clockevent.min_delta_ns =
738                 clockevent_delta2ns(0x1, &tegra_clockevent);
739         tegra_clockevent.cpumask = cpu_all_mask;
740         tegra_clockevent.irq = tegra_timer_irq.irq;
741         clockevents_register_device(&tegra_clockevent);
742
743         register_syscore_ops(&tegra_timer_syscore_ops);
744         late_time_init = tegra_init_late_timer;
745 }
746
747 struct sys_timer tegra_timer = {
748         .init = tegra_init_timer,
749 };