ARM: Build fix after Tegra14 K3.4 merge
[linux-3.10.git] / arch / arm / mach-tegra / timer.c
index e7acbed..540d1ed 100644 (file)
@@ -49,8 +49,6 @@
 #include "timer.h"
 #include "fuse.h"
 
-extern int __init arch_timer_register(struct arch_timer *at);
-
 static void __iomem *timer_reg_base = IO_ADDRESS(TEGRA_TMR1_BASE);
 static void __iomem *rtc_base = IO_ADDRESS(TEGRA_RTC_BASE);
 
@@ -119,6 +117,11 @@ static u32 notrace tegra_read_usec(void)
        return cyc;
 }
 
+u32 notrace tegra_read_usec_raw(void)
+{
+       return timer_readl(TIMERUS_CNTR_1US);
+}
+
 static u32 notrace tegra_read_sched_clock(void)
 {
        return tegra_read_usec();
@@ -130,7 +133,7 @@ static u32 notrace tegra_read_sched_clock(void)
  * tegra_rtc driver could be executing to avoid race conditions
  * on the RTC shadow register
  */
-static u64 tegra_rtc_read_ms(void)
+u64 tegra_rtc_read_ms(void)
 {
        u32 ms = readl(rtc_base + RTC_MILLISECONDS);
        u32 s = readl(rtc_base + RTC_SHADOW_SECONDS);
@@ -209,10 +212,9 @@ static DEFINE_TWD_LOCAL_TIMER(twd_local_timer,
                              IRQ_LOCALTIMER);
 static void __iomem *tegra_twd_base = IO_ADDRESS(TEGRA_ARM_PERIF_BASE + 0x600);
 
-void __init tegra_twd_init(void)
+void __init tegra_cpu_timer_init(void)
 {
        struct clk *cpu, *twd_clk;
-       int ret;
        int err;
 
        /* The twd clock is a detached child of the CPU complex clock.
@@ -222,16 +224,12 @@ void __init tegra_twd_init(void)
        twd_clk = tegra_get_clock_by_name("twd");
        BUG_ON(!twd_clk);
        cpu = tegra_get_clock_by_name("cpu");
-       ret = clk_set_rate(twd_clk, clk_get_rate(cpu));
+       err = clk_set_rate(twd_clk, clk_get_rate(cpu));
 
-       if (ret)
-               pr_err("Failed to set twd clock rate: %d\n", ret);
+       if (err)
+               pr_err("Failed to set twd clock rate: %d\n", err);
        else
                pr_debug("TWD clock rate: %ld\n", clk_get_rate(twd_clk));
-
-       err = twd_local_timer_register(&twd_local_timer);
-       if (err)
-               pr_err("twd_local_timer_register failed %d\n", err);
 }
 
 int tegra_twd_get_state(struct tegra_twd_context *context)
@@ -267,24 +265,65 @@ void tegra_twd_resume(struct tegra_twd_context *context)
        writel(context->twd_ctrl, tegra_twd_base + TWD_TIMER_CONTROL);
 }
 
-static void __init tegra_init_late_twd(void)
+static void __init tegra_init_late_timer(void)
 {
        int err = twd_local_timer_register(&twd_local_timer);
        if (err)
                pr_err("twd_timer_register failed %d\n", err);
 }
 #else
-#define tegra_twd_init()       do {} while(0)
-static inline void tegra_init_late_twd(void) {}
 #define tegra_twd_get_state    do {} while(0)
 #define tegra_twd_suspend      do {} while(0)
 #define tegra_twd_resume       do {} while(0)
+void __init tegra_cpu_timer_init(void) {}
+static void __init tegra_init_late_timer(void) {}
+#endif
+
+#ifdef CONFIG_ARM_ARCH_TIMER
+int arch_timer_get_state(struct arch_timer_context *context)
+{
+       s32 val;
+
+       asm volatile("mrc p15, 0, %0, c14, c2, 0" : "=r" (val));
+       context->cntp_tval = val;
+       asm volatile("mrc p15, 0, %0, c14, c2, 1" : "=r" (val));
+       context->cntp_ctl = val;
+       asm volatile("mrc p15, 0, %0, c14, c0, 0" : "=r" (val));
+       context->cntfrq = val;
+       return 0;
+}
+
+void arch_timer_suspend(struct arch_timer_context *context)
+{
+       s32 val;
+
+       asm volatile("mrc p15, 0, %0, c14, c2, 0" : "=r" (val));
+       context->cntp_tval = val;
+       asm volatile("mrc p15, 0, %0, c14, c2, 1" : "=r" (val));
+       context->cntp_ctl = val;
+}
+
+void arch_timer_resume(struct arch_timer_context *context)
+{
+       s32 val;
+
+       val = context->cntp_tval;
+       asm volatile("mcr p15, 0, %0, c14, c2, 0" : : "r"(val));
+       val = context->cntp_ctl;
+       asm volatile("mcr p15, 0, %0, c14, c2, 1" : : "r"(val));
+}
+#else
+#define arch_timer_get_state do {} while(0)
+#define arch_timer_suspend do {} while(0)
+#define arch_timer_resume do {} while(0)
 #endif
 
 #ifdef CONFIG_ARM_ARCH_TIMER
 
+#ifndef CONFIG_TRUSTED_FOUNDATIONS
 /* Time Stamp Counter (TSC) base address */
 static void __iomem *tsc = IO_ADDRESS(TEGRA_TSC_BASE);
+#endif
 static bool arch_timer_initialized;
 
 #define TSC_CNTCR              0               /* TSC control registers */
@@ -304,22 +343,20 @@ static bool arch_timer_initialized;
 /* Is the optional system timer available? */
 static int local_timer_is_architected(void)
 {
-#ifdef CONFIG_TEGRA_SIMULATION_PLATFORM
-       /* HACK: The simulator does not yet support arch timers. */
-       return 0;
-#else
        return (cpu_architecture() >= CPU_ARCH_ARMv7) &&
               ((read_cpuid_ext(CPUID_EXT_PFR1) >> 16) & 0xf) == 1;
-#endif
 }
 
-static int __init tegra_init_early_arch_timer(void)
+void __init tegra_cpu_timer_init(void)
 {
+#ifdef CONFIG_TRUSTED_FOUNDATIONS
+       return;
+#else
        u32 tsc_ref_freq;
        u32 reg;
 
        if (!local_timer_is_architected())
-               return -ENODEV;
+               return;
 
        tsc_ref_freq = tegra_clk_measure_input_freq();
        if (tsc_ref_freq == 115200 || tsc_ref_freq == 230400) {
@@ -347,11 +384,14 @@ static int __init tegra_init_early_arch_timer(void)
        reg = tsc_readl(TSC_CNTCR);
        reg |= TSC_CNTCR_ENABLE | TSC_CNTCR_HDBG;
        tsc_writel(reg, TSC_CNTCR);
-       return 0;
+#endif
 }
 
 static void tegra_arch_timer_per_cpu_init(void)
 {
+#ifdef CONFIG_TRUSTED_FOUNDATIONS
+       return;
+#else
        if (arch_timer_initialized) {
                u32 tsc_ref_freq = tegra_clk_measure_input_freq();
 
@@ -366,6 +406,7 @@ static void tegra_arch_timer_per_cpu_init(void)
                   NOTE: this is a write once (per CPU reset) register. */
                __asm__("mcr p15, 0, %0, c14, c0, 0\n" : : "r" (tsc_ref_freq));
        }
+#endif
 }
 
 static int arch_timer_cpu_notify(struct notifier_block *self,
@@ -394,7 +435,6 @@ static int arch_timer_cpu_pm_notify(struct notifier_block *self,
        case CPU_PM_EXIT:
                tegra_arch_timer_per_cpu_init();
                break;
-               break;
        }
 
        return NOTIFY_OK;
@@ -411,6 +451,8 @@ static int __init tegra_init_arch_timer(void)
        if (!local_timer_is_architected())
                return -ENODEV;
 
+       arch_timer_of_register();
+
        err = arch_timer_sched_clock_init();
        if (err) {
                pr_err("%s: Unable to initialize arch timer sched_clock: %d\n",
@@ -424,31 +466,8 @@ static int __init tegra_init_arch_timer(void)
        return 0;
 }
 
-static struct arch_timer tegra_arch_timer = {
-       .res[0] = {
-               .start  = 29,
-               .end    = 29,
-               .flags  = IORESOURCE_IRQ,
-       },
-       .res[1] = {
-               .start  = 30,
-               .end    = 30,
-               .flags  = IORESOURCE_IRQ,
-       },
-};
-
-static int __init tegra_init_late_arch_timer(void)
-{
-       int err = -ENODEV;
-
-       if (arch_timer_initialized) {
-               err = arch_timer_register(&tegra_arch_timer);
-               if (err)
-                       pr_err("%s: Unable to register arch timer: %d\n",
-                            __func__, err);
-       }
-       return err;
-}
+static void __init tegra_init_late_timer(void)
+{}
 
 #ifdef CONFIG_PM_SLEEP
 
@@ -518,23 +537,10 @@ void tegra_tsc_wait_for_resume(void)
 #endif
 
 #else
-static inline int tegra_init_early_arch_timer(void) { return -ENODEV; }
 static inline int tegra_init_arch_timer(void) { return -ENODEV; }
 static inline int tegra_init_late_arch_timer(void) { return -ENODEV; }
 #endif
 
-void __init tegra_init_early_timer(void)
-{
-       if (tegra_init_early_arch_timer())
-               tegra_twd_init();
-}
-
-static void __init tegra_init_late_timer(void)
-{
-       if (tegra_init_late_arch_timer())
-               tegra_init_late_twd();
-}
-
 extern void __tegra_delay(unsigned long cycles);
 extern void __tegra_const_udelay(unsigned long loops);
 extern void __tegra_udelay(unsigned long usecs);
@@ -550,7 +556,7 @@ void __init tegra_init_timer(void)
                pr_warn("Unable to get timer clock. Assuming 12Mhz input clock.\n");
                rate = 12000000;
        } else {
-               clk_prepare_enable(clk);
+               tegra_clk_prepare_enable(clk);
                rate = clk_get_rate(clk);
        }
 
@@ -562,7 +568,7 @@ void __init tegra_init_timer(void)
        if (IS_ERR(clk))
                pr_warn("Unable to get rtc-tegra clock\n");
        else
-               clk_prepare_enable(clk);
+               tegra_clk_prepare_enable(clk);
 
        switch (rate) {
        case 12000000:
@@ -589,7 +595,7 @@ void __init tegra_init_timer(void)
                break;
 #endif
        default:
-               if (tegra_revision == TEGRA_REVISION_QT) {
+               if (tegra_platform_is_qt()) {
                        timer_writel(0x000c, TIMERUS_USEC_CFG);
                        break;
                }
@@ -605,43 +611,42 @@ void __init tegra_init_timer(void)
        /* Architectural timers take precedence over broadcast timers.
           Only register a broadcast clockevent device if architectural
           timers do not exist or cannot be initialized. */
-       if (tegra_init_arch_timer()) {
+       if (tegra_init_arch_timer())
                /* Architectural timers do not exist or cannot be initialzied.
                   Fall back to using the broadcast timer as the sched clock. */
                setup_sched_clock(tegra_read_sched_clock, 32, 1000000);
 
-               ret = clocksource_mmio_init(timer_reg_base + TIMERUS_CNTR_1US,
-                       "timer_us", 1000000, 300, 32,
-                       clocksource_mmio_readl_up);
-               if (ret) {
-                       pr_err("%s: Failed to register clocksource: %d\n",
-                               __func__, ret);
-                       BUG();
-               }
-
-               ret = setup_irq(tegra_timer_irq.irq, &tegra_timer_irq);
-               if (ret) {
-                       pr_err("%s: Failed to register timer IRQ: %d\n",
-                               __func__, ret);
-                       BUG();
-               }
+       ret = clocksource_mmio_init(timer_reg_base + TIMERUS_CNTR_1US,
+               "timer_us", 1000000, 300, 32,
+               clocksource_mmio_readl_up);
+       if (ret) {
+               pr_err("%s: Failed to register clocksource: %d\n",
+                       __func__, ret);
+               BUG();
+       }
 
-               clockevents_calc_mult_shift(&tegra_clockevent, 1000000, 5);
-               tegra_clockevent.max_delta_ns =
-                       clockevent_delta2ns(0x1fffffff, &tegra_clockevent);
-               tegra_clockevent.min_delta_ns =
-                       clockevent_delta2ns(0x1, &tegra_clockevent);
-               tegra_clockevent.cpumask = cpu_all_mask;
-               tegra_clockevent.irq = tegra_timer_irq.irq;
-               clockevents_register_device(&tegra_clockevent);
+       ret = setup_irq(tegra_timer_irq.irq, &tegra_timer_irq);
+       if (ret) {
+               pr_err("%s: Failed to register timer IRQ: %d\n",
+                       __func__, ret);
+               BUG();
        }
 
+       clockevents_calc_mult_shift(&tegra_clockevent, 1000000, 5);
+       tegra_clockevent.max_delta_ns =
+               clockevent_delta2ns(0x1fffffff, &tegra_clockevent);
+       tegra_clockevent.min_delta_ns =
+               clockevent_delta2ns(0x1, &tegra_clockevent);
+       tegra_clockevent.cpumask = cpu_all_mask;
+       tegra_clockevent.irq = tegra_timer_irq.irq;
+       clockevents_register_device(&tegra_clockevent);
+
        register_syscore_ops(&tegra_timer_syscore_ops);
        late_time_init = tegra_init_late_timer;
 
        register_persistent_clock(NULL, tegra_read_persistent_clock);
 
-       arm_delay_ops.delay             = __tegra_delay;
-       arm_delay_ops.const_udelay      = __tegra_const_udelay;
-       arm_delay_ops.udelay            = __tegra_udelay;
+       //arm_delay_ops.delay           = __tegra_delay;
+       //arm_delay_ops.const_udelay    = __tegra_const_udelay;
+       //arm_delay_ops.udelay          = __tegra_udelay;
 }