ARC: clockevent: DT based probe

[cascardo/linux.git] / arch / arc / kernel / time.c

diff --git a/arch/arc/kernel/time.c b/arch/arc/kernel/time.c
index 7d9a736..01ec30d 100644 (file)
--- a/arch/arc/kernel/time.c
+++ b/arch/arc/kernel/time.c
@@ -29,21 +29,16 @@
  * which however is currently broken
  */
 
-#include <linux/spinlock.h>
 #include <linux/interrupt.h>
-#include <linux/module.h>
-#include <linux/sched.h>
-#include <linux/kernel.h>
-#include <linux/time.h>
-#include <linux/init.h>
-#include <linux/timex.h>
-#include <linux/profile.h>
+#include <linux/clk.h>
+#include <linux/clk-provider.h>
 #include <linux/clocksource.h>
 #include <linux/clockchips.h>
+#include <linux/cpu.h>
+#include <linux/of.h>
+#include <linux/of_irq.h>
 #include <asm/irq.h>
 #include <asm/arcregs.h>
-#include <asm/clk.h>
-#include <asm/mach_desc.h>
 
 #include <asm/mcip.h>
 
@@ -60,6 +55,30 @@
 
 #define ARC_TIMER_MAX  0xFFFFFFFF
 
+static unsigned long arc_timer_freq;
+
+static int noinline arc_get_timer_clk(struct device_node *node)
+{
+       struct clk *clk;
+       int ret;
+
+       clk = of_clk_get(node, 0);
+       if (IS_ERR(clk)) {
+               pr_err("timer missing clk");
+               return PTR_ERR(clk);
+       }
+
+       ret = clk_prepare_enable(clk);
+       if (ret) {
+               pr_err("Couldn't enable parent clk\n");
+               return ret;
+       }
+
+       arc_timer_freq = clk_get_rate(clk);
+
+       return 0;
+}
+
 /********** Clock Source Device *********/
 
 #ifdef CONFIG_ARC_HAS_GFRC
@@ -183,6 +202,8 @@ static struct clocksource arc_counter = {
 
 /********** Clock Event Device *********/
 
+static int arc_timer_irq;
+
 /*
  * Arm the timer to interrupt after @cycles
  * The distinction for oneshot/periodic is done in arc_event_timer_ack() below
@@ -209,7 +230,7 @@ static int arc_clkevent_set_periodic(struct clock_event_device *dev)
         * At X Hz, 1 sec = 1000ms -> X cycles;
         *                    10ms -> X / 100 cycles
         */
-       arc_timer_event_setup(arc_get_core_freq() / HZ);
+       arc_timer_event_setup(arc_timer_freq / HZ);
        return 0;
 }
 
@@ -218,7 +239,6 @@ static DEFINE_PER_CPU(struct clock_event_device, arc_clockevent_device) = {
        .features               = CLOCK_EVT_FEAT_ONESHOT |
                                  CLOCK_EVT_FEAT_PERIODIC,
        .rating                 = 300,
-       .irq                    = TIMER0_IRQ,   /* hardwired, no need for resources */
        .set_next_event         = arc_clkevent_set_next_event,
        .set_state_periodic     = arc_clkevent_set_periodic,
 };
@@ -244,22 +264,63 @@ static irqreturn_t timer_irq_handler(int irq, void *dev_id)
        return IRQ_HANDLED;
 }
 
+static int arc_timer_cpu_notify(struct notifier_block *self,
+                               unsigned long action, void *hcpu)
+{
+       struct clock_event_device *evt = this_cpu_ptr(&arc_clockevent_device);
+
+       evt->cpumask = cpumask_of(smp_processor_id());
+
+       switch (action & ~CPU_TASKS_FROZEN) {
+       case CPU_STARTING:
+               clockevents_config_and_register(evt, arc_timer_freq,
+                                               0, ULONG_MAX);
+               enable_percpu_irq(arc_timer_irq, 0);
+               break;
+       case CPU_DYING:
+               disable_percpu_irq(arc_timer_irq);
+               break;
+       }
+
+       return NOTIFY_OK;
+}
+
+static struct notifier_block arc_timer_cpu_nb = {
+       .notifier_call = arc_timer_cpu_notify,
+};
+
 /*
- * Setup the local event timer for @cpu
+ * clockevent setup for boot CPU
  */
-void arc_local_timer_setup()
+static void __init arc_clockevent_setup(struct device_node *node)
 {
        struct clock_event_device *evt = this_cpu_ptr(&arc_clockevent_device);
-       int cpu = smp_processor_id();
+       int ret;
 
-       evt->cpumask = cpumask_of(cpu);
-       clockevents_config_and_register(evt, arc_get_core_freq(),
+       register_cpu_notifier(&arc_timer_cpu_nb);
+
+       arc_timer_irq = irq_of_parse_and_map(node, 0);
+       if (arc_timer_irq <= 0)
+               panic("clockevent: missing irq");
+
+       ret = arc_get_timer_clk(node);
+       if (ret)
+               panic("clockevent: missing clk");
+
+       evt->irq = arc_timer_irq;
+       evt->cpumask = cpumask_of(smp_processor_id());
+       clockevents_config_and_register(evt, arc_timer_freq,
                                        0, ARC_TIMER_MAX);
 
-       /* setup the per-cpu timer IRQ handler - for all cpus */
-       arc_request_percpu_irq(TIMER0_IRQ, cpu, timer_irq_handler,
-                              "Timer0 (per-cpu-tick)", evt);
+       /* Needs apriori irq_set_percpu_devid() done in intc map function */
+       ret = request_percpu_irq(arc_timer_irq, timer_irq_handler,
+                                "Timer0 (per-cpu-tick)", evt);
+       if (ret)
+               panic("clockevent: unable to request irq\n");
+
+       enable_percpu_irq(arc_timer_irq, 0);
 }
+CLOCKSOURCE_OF_DECLARE(arc_clkevt, "snps,arc-timer", arc_clockevent_setup);
 
 /*
  * Called from start_kernel() - boot CPU only
@@ -268,10 +329,12 @@ void arc_local_timer_setup()
  * -Also sets up any global state needed for timer subsystem:
  *    - for "counting" timer, registers a clocksource, usable across CPUs
  *      (provided that underlying counter h/w is synchronized across cores)
- *    - for "event" timer, sets up TIMER0 IRQ (as that is platform agnostic)
  */
 void __init time_init(void)
 {
+       of_clk_init(NULL);
+       clocksource_probe();
+
        /*
         * sets up the timekeeping free-flowing counter which also returns
         * whether the counter is usable as clocksource
@@ -281,8 +344,5 @@ void __init time_init(void)
                 * CLK upto 4.29 GHz can be safely represented in 32 bits
                 * because Max 32 bit number is 4,294,967,295
                 */
-               clocksource_register_hz(&arc_counter, arc_get_core_freq());
-
-       /* sets up the periodic event timer */
-       arc_local_timer_setup();
+               clocksource_register_hz(&arc_counter, arc_timer_freq);
 }