From: Olof Johansson Date: Tue, 23 Jul 2013 21:51:34 +0000 (-0700) Subject: Merge tag 'remove-local-timers' of git://git.kernel.org/pub/scm/linux/kernel/git... X-Git-Tag: firefly_0821_release~176^2~5405^2~14 X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=47dcd3563e45fc5a59bf7f3326ef56087be8bebe;p=firefly-linux-kernel-4.4.55.git Merge tag 'remove-local-timers' of git://git./linux/kernel/git/davidb/linux-msm into next/cleanup From Stephen Boyd: Now that we have a generic arch hook for broadcast we can remove the local timer API entirely. Doing so will reduce code in ARM core, reduce the architecture dependencies of our timer drivers, and simplify the code because we no longer go through an architecture layer that is essentially a hotplug notifier. * tag 'remove-local-timers' of git://git.kernel.org/pub/scm/linux/kernel/git/davidb/linux-msm: ARM: smp: Remove local timer API clocksource: time-armada-370-xp: Divorce from local timer API clocksource: time-armada-370-xp: Fix sparse warning ARM: msm: Divorce msm_timer from local timer API ARM: PRIMA2: Divorce timer-marco from local timer API ARM: EXYNOS4: Divorce mct from local timer API ARM: OMAP2+: Divorce from local timer API ARM: smp_twd: Divorce smp_twd from local timer API ARM: smp: Remove duplicate dummy timer implementation Resolved a large number of conflicts due to __cpuinit cleanups, etc. Signed-off-by: Olof Johansson --- 47dcd3563e45fc5a59bf7f3326ef56087be8bebe diff --cc arch/arm/kernel/smp_twd.c index 25956204ef23,aac1495b44de..2985c9f0905d --- a/arch/arm/kernel/smp_twd.c +++ b/arch/arm/kernel/smp_twd.c @@@ -265,9 -267,9 +267,9 @@@ static void twd_get_clock(struct device /* * Setup the local clock events for a CPU. */ - static int twd_timer_setup(struct clock_event_device *clk) -static void __cpuinit twd_timer_setup(void) ++static void twd_timer_setup(void) { - struct clock_event_device **this_cpu_clk; + struct clock_event_device *clk = __this_cpu_ptr(twd_evt); int cpu = smp_processor_id(); /* @@@ -304,13 -304,25 +304,25 @@@ clockevents_config_and_register(clk, twd_timer_rate, 0xf, 0xffffffff); enable_percpu_irq(clk->irq, 0); + } - return 0; -static int __cpuinit twd_timer_cpu_notify(struct notifier_block *self, - unsigned long action, void *hcpu) ++static int twd_timer_cpu_notify(struct notifier_block *self, ++ unsigned long action, void *hcpu) + { + switch (action & ~CPU_TASKS_FROZEN) { + case CPU_STARTING: + twd_timer_setup(); + break; + case CPU_DYING: + twd_timer_stop(); + break; + } + + return NOTIFY_OK; } - static struct local_timer_ops twd_lt_ops = { - .setup = twd_timer_setup, - .stop = twd_timer_stop, -static struct notifier_block twd_timer_cpu_nb __cpuinitdata = { ++static struct notifier_block twd_timer_cpu_nb = { + .notifier_call = twd_timer_cpu_notify, }; static int __init twd_local_timer_common_register(struct device_node *np) diff --cc arch/arm/mach-msm/timer.c index 8697cfc0d0b6,dacdcfdbc342..a7afbacae61a --- a/arch/arm/mach-msm/timer.c +++ b/arch/arm/mach-msm/timer.c @@@ -138,23 -127,34 +127,34 @@@ static struct clocksource msm_clocksour .flags = CLOCK_SOURCE_IS_CONTINUOUS, }; - #ifdef CONFIG_LOCAL_TIMERS + static int msm_timer_irq; + static int msm_timer_has_ppi; + -static int __cpuinit msm_local_timer_setup(struct clock_event_device *evt) +static int msm_local_timer_setup(struct clock_event_device *evt) { - /* Use existing clock_event for cpu 0 */ - if (!smp_processor_id()) - return 0; - - evt->irq = msm_clockevent.irq; - evt->name = "local_timer"; - evt->features = msm_clockevent.features; - evt->rating = msm_clockevent.rating; + int cpu = smp_processor_id(); + int err; + + evt->irq = msm_timer_irq; + evt->name = "msm_timer"; + evt->features = CLOCK_EVT_FEAT_ONESHOT; + evt->rating = 200; evt->set_mode = msm_timer_set_mode; evt->set_next_event = msm_timer_set_next_event; + evt->cpumask = cpumask_of(cpu); + + clockevents_config_and_register(evt, GPT_HZ, 4, 0xffffffff); + + if (msm_timer_has_ppi) { + enable_percpu_irq(evt->irq, IRQ_TYPE_EDGE_RISING); + } else { + err = request_irq(evt->irq, msm_timer_interrupt, + IRQF_TIMER | IRQF_NOBALANCING | + IRQF_TRIGGER_RISING, "gp_timer", evt); + if (err) + pr_err("request_irq failed\n"); + } - *__this_cpu_ptr(msm_evt.percpu_evt) = evt; - clockevents_config_and_register(evt, GPT_HZ, 4, 0xf0000000); - enable_percpu_irq(evt->irq, IRQ_TYPE_EDGE_RISING); return 0; } @@@ -164,11 -164,28 +164,28 @@@ static void msm_local_timer_stop(struc disable_percpu_irq(evt->irq); } - static struct local_timer_ops msm_local_timer_ops = { - .setup = msm_local_timer_setup, - .stop = msm_local_timer_stop, -static int __cpuinit msm_timer_cpu_notify(struct notifier_block *self, ++static int msm_timer_cpu_notify(struct notifier_block *self, + unsigned long action, void *hcpu) + { + /* + * Grab cpu pointer in each case to avoid spurious + * preemptible warnings + */ + switch (action & ~CPU_TASKS_FROZEN) { + case CPU_STARTING: + msm_local_timer_setup(this_cpu_ptr(msm_evt)); + break; + case CPU_DYING: + msm_local_timer_stop(this_cpu_ptr(msm_evt)); + break; + } + + return NOTIFY_OK; + } + -static struct notifier_block msm_timer_cpu_nb __cpuinitdata = { ++static struct notifier_block msm_timer_cpu_nb = { + .notifier_call = msm_timer_cpu_notify, }; - #endif /* CONFIG_LOCAL_TIMERS */ static notrace u32 msm_sched_clock_read(void) { diff --cc drivers/clocksource/exynos_mct.c index b2bbc415f120,1c3f5a652044..5b34768f4d7c --- a/drivers/clocksource/exynos_mct.c +++ b/drivers/clocksource/exynos_mct.c @@@ -448,11 -462,32 +445,32 @@@ static void exynos4_local_timer_stop(st disable_percpu_irq(mct_irqs[MCT_L0_IRQ]); } - static struct local_timer_ops exynos4_mct_tick_ops = { - .setup = exynos4_local_timer_setup, - .stop = exynos4_local_timer_stop, -static int __cpuinit exynos4_mct_cpu_notify(struct notifier_block *self, ++static int exynos4_mct_cpu_notify(struct notifier_block *self, + unsigned long action, void *hcpu) + { + struct mct_clock_event_device *mevt; + + /* + * Grab cpu pointer in each case to avoid spurious + * preemptible warnings + */ + switch (action & ~CPU_TASKS_FROZEN) { + case CPU_STARTING: + mevt = this_cpu_ptr(&percpu_mct_tick); + exynos4_local_timer_setup(&mevt->evt); + break; + case CPU_DYING: + mevt = this_cpu_ptr(&percpu_mct_tick); + exynos4_local_timer_stop(&mevt->evt); + break; + } + + return NOTIFY_OK; + } + -static struct notifier_block exynos4_mct_cpu_nb __cpuinitdata = { ++static struct notifier_block exynos4_mct_cpu_nb = { + .notifier_call = exynos4_mct_cpu_notify, }; - #endif /* CONFIG_LOCAL_TIMERS */ static void __init exynos4_timer_resources(struct device_node *np, void __iomem *base) { diff --cc drivers/clocksource/time-armada-370-xp.c index 1b04b7e1d39b,f86542002ee1..847cab6f6e31 --- a/drivers/clocksource/time-armada-370-xp.c +++ b/drivers/clocksource/time-armada-370-xp.c @@@ -199,15 -188,33 +188,33 @@@ static int armada_370_xp_timer_setup(st return 0; } - static void armada_370_xp_timer_stop(struct clock_event_device *evt) -static void __cpuinit armada_370_xp_timer_stop(struct clock_event_device *evt) ++static void armada_370_xp_timer_stop(struct clock_event_device *evt) { evt->set_mode(CLOCK_EVT_MODE_UNUSED, evt); disable_percpu_irq(evt->irq); } - static struct local_timer_ops armada_370_xp_local_timer_ops = { - .setup = armada_370_xp_timer_setup, - .stop = armada_370_xp_timer_stop, -static int __cpuinit armada_370_xp_timer_cpu_notify(struct notifier_block *self, ++static int armada_370_xp_timer_cpu_notify(struct notifier_block *self, + unsigned long action, void *hcpu) + { + /* + * Grab cpu pointer in each case to avoid spurious + * preemptible warnings + */ + switch (action & ~CPU_TASKS_FROZEN) { + case CPU_STARTING: + armada_370_xp_timer_setup(this_cpu_ptr(armada_370_xp_evt)); + break; + case CPU_DYING: + armada_370_xp_timer_stop(this_cpu_ptr(armada_370_xp_evt)); + break; + } + + return NOTIFY_OK; + } + -static struct notifier_block armada_370_xp_timer_cpu_nb __cpuinitdata = { ++static struct notifier_block armada_370_xp_timer_cpu_nb = { + .notifier_call = armada_370_xp_timer_cpu_notify, }; void __init armada_370_xp_timer_init(void) diff --cc drivers/clocksource/timer-marco.c index 62876baa3ab9,01b9683557b2..09a17d9a6594 --- a/drivers/clocksource/timer-marco.c +++ b/drivers/clocksource/timer-marco.c @@@ -184,43 -175,69 +175,69 @@@ static struct irqaction sirfsoc_timer1_ .handler = sirfsoc_timer_interrupt, }; -static int __cpuinit sirfsoc_local_timer_setup(struct clock_event_device *ce) +static int sirfsoc_local_timer_setup(struct clock_event_device *ce) { - /* Use existing clock_event for cpu 0 */ - if (!smp_processor_id()) - return 0; + int cpu = smp_processor_id(); + struct irqaction *action; + + if (cpu == 0) + action = &sirfsoc_timer_irq; + else + action = &sirfsoc_timer1_irq; - ce->irq = sirfsoc_timer1_irq.irq; + ce->irq = action->irq; ce->name = "local_timer"; - ce->features = sirfsoc_clockevent.features; - ce->rating = sirfsoc_clockevent.rating; + ce->features = CLOCK_EVT_FEAT_ONESHOT; + ce->rating = 200; ce->set_mode = sirfsoc_timer_set_mode; ce->set_next_event = sirfsoc_timer_set_next_event; - ce->shift = sirfsoc_clockevent.shift; - ce->mult = sirfsoc_clockevent.mult; - ce->max_delta_ns = sirfsoc_clockevent.max_delta_ns; - ce->min_delta_ns = sirfsoc_clockevent.min_delta_ns; + clockevents_calc_mult_shift(ce, CLOCK_TICK_RATE, 60); + ce->max_delta_ns = clockevent_delta2ns(-2, ce); + ce->min_delta_ns = clockevent_delta2ns(2, ce); + ce->cpumask = cpumask_of(cpu); - sirfsoc_timer1_irq.dev_id = ce; - BUG_ON(setup_irq(ce->irq, &sirfsoc_timer1_irq)); - irq_set_affinity(sirfsoc_timer1_irq.irq, cpumask_of(1)); + action->dev_id = ce; + BUG_ON(setup_irq(ce->irq, action)); + irq_set_affinity(action->irq, cpumask_of(cpu)); clockevents_register_device(ce); return 0; } -static void __cpuinit sirfsoc_local_timer_stop(struct clock_event_device *ce) +static void sirfsoc_local_timer_stop(struct clock_event_device *ce) { + int cpu = smp_processor_id(); + sirfsoc_timer_count_disable(1); - remove_irq(sirfsoc_timer1_irq.irq, &sirfsoc_timer1_irq); + if (cpu == 0) + remove_irq(sirfsoc_timer_irq.irq, &sirfsoc_timer_irq); + else + remove_irq(sirfsoc_timer1_irq.irq, &sirfsoc_timer1_irq); } - static struct local_timer_ops sirfsoc_local_timer_ops = { - .setup = sirfsoc_local_timer_setup, - .stop = sirfsoc_local_timer_stop, -static int __cpuinit sirfsoc_cpu_notify(struct notifier_block *self, - unsigned long action, void *hcpu) ++static int sirfsoc_cpu_notify(struct notifier_block *self, ++ unsigned long action, void *hcpu) + { + /* + * Grab cpu pointer in each case to avoid spurious + * preemptible warnings + */ + switch (action & ~CPU_TASKS_FROZEN) { + case CPU_STARTING: + sirfsoc_local_timer_setup(this_cpu_ptr(sirfsoc_clockevent)); + break; + case CPU_DYING: + sirfsoc_local_timer_stop(this_cpu_ptr(sirfsoc_clockevent)); + break; + } + + return NOTIFY_OK; + } + -static struct notifier_block sirfsoc_cpu_nb __cpuinitdata = { ++static struct notifier_block sirfsoc_cpu_nb = { + .notifier_call = sirfsoc_cpu_notify, }; - #endif /* CONFIG_LOCAL_TIMERS */ static void __init sirfsoc_clockevent_init(void) {