Merge tag 'cleanup-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc

Pull ARM SoC cleanups from Olof Johansson:
 "This branch contains code cleanups, moves and removals for 3.12.

  There's a large number of various cleanups, and a nice net removal of
  13500 lines of code.

  Highlights worth mentioning are:

   - A series of patches from Stephen Boyd removing the ARM local timer
     API.
   - Move of Qualcomm MSM IOMMU code to drivers/iommu.
   - Samsung PWM driver cleanups from Tomasz Figa, removing legacy PWM
     driver and switching over to the drivers/pwm one.
   - Removal of some unusued auto-generated headers for OMAP2+ (PRM/CM).

  There's also a move of a header file out of include/linux/i2c/ to
  platform_data, where it really belongs.  It touches mostly ARM
  platform code for include changes so we took it through our tree"

* tag 'cleanup-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc: (83 commits)
  ARM: OMAP2+: Add back the define for AM33XX_RST_GLOBAL_WARM_SW_MASK
  gpio: (gpio-pca953x) move header to linux/platform_data/
  arm: zynq: hotplug: Remove unreachable code
  ARM: SAMSUNG: Remove unnecessary exynos4_default_sdhci*()
  tegra: simplify use of devm_ioremap_resource
  ARM: SAMSUNG: Remove plat/regs-timer.h header
  ARM: SAMSUNG: Remove remaining uses of plat/regs-timer.h header
  ARM: SAMSUNG: Remove pwm-clock infrastructure
  ARM: SAMSUNG: Remove old PWM timer platform devices
  pwm: Remove superseded pwm-samsung-legacy driver
  ARM: SAMSUNG: Modify board files to use new PWM platform device
  ARM: SAMSUNG: Rework private data handling in dev-backlight
  pwm: Add new pwm-samsung driver
  ARM: mach-mvebu: remove redundant DT parsing and validation
  ARM: msm: Only compile io.c on platforms that use it
  iommu/msm: Move mach includes to iommu directory
  ARM: msm: Remove devices-iommu.c
  ARM: msm: Move mach/board.h contents to common.h
  ARM: msm: Migrate msm_timer to CLOCKSOURCE_OF_DECLARE
  ARM: msm: Remove TMR and TMR0 static mappings
  ...

5 files changed, 197 insertions, 160 deletions

diff --git a/drivers/clocksource/Kconfig b/drivers/clocksource/Kconfig
index b7b9b040a89b..41c69469ce20 100644
--- a/drivers/clocksource/Kconfig
+++ b/drivers/clocksource/Kconfig
@@ -99,7 +99,6 @@ config CLKSRC_EXYNOS_MCT
 
 config CLKSRC_SAMSUNG_PWM
         bool
-        select CLKSRC_MMIO
         help
           This is a new clocksource driver for the PWM timer found in
           Samsung S3C, S5P and Exynos SoCs, replacing an earlier driver
diff --git a/drivers/clocksource/exynos_mct.c b/drivers/clocksource/exynos_mct.c
index b2bbc415f120..5b34768f4d7c 100644
--- a/drivers/clocksource/exynos_mct.c
+++ b/drivers/clocksource/exynos_mct.c
@@ -16,6 +16,7 @@
 #include <linux/err.h>
 #include <linux/clk.h>
 #include <linux/clockchips.h>
+#include <linux/cpu.h>
 #include <linux/platform_device.h>
 #include <linux/delay.h>
 #include <linux/percpu.h>
@@ -24,7 +25,6 @@
 #include <linux/of_address.h>
 #include <linux/clocksource.h>
 
-#include <asm/localtimer.h>
 #include <asm/mach/time.h>
 
 #define EXYNOS4_MCTREG(x)               (x)
@@ -80,7 +80,7 @@ static unsigned int mct_int_type;
 static int mct_irqs[MCT_NR_IRQS];
 
 struct mct_clock_event_device {
-        struct clock_event_device *evt;
+        struct clock_event_device evt;
         unsigned long base;
         char name[10];
 };
@@ -295,8 +295,6 @@ static void exynos4_clockevent_init(void)
         setup_irq(mct_irqs[MCT_G0_IRQ], &mct_comp_event_irq);
 }
 
-#ifdef CONFIG_LOCAL_TIMERS
-
 static DEFINE_PER_CPU(struct mct_clock_event_device, percpu_mct_tick);
 
 /* Clock event handling */
@@ -369,7 +367,7 @@ static inline void exynos4_tick_set_mode(enum clock_event_mode mode,
 
 static int exynos4_mct_tick_clear(struct mct_clock_event_device *mevt)
 {
-        struct clock_event_device *evt = mevt->evt;
+        struct clock_event_device *evt = &mevt->evt;
 
         /*
          * This is for supporting oneshot mode.
@@ -391,7 +389,7 @@ static int exynos4_mct_tick_clear(struct mct_clock_event_device *mevt)
 static irqreturn_t exynos4_mct_tick_isr(int irq, void *dev_id)
 {
         struct mct_clock_event_device *mevt = dev_id;
-        struct clock_event_device *evt = mevt->evt;
+        struct clock_event_device *evt = &mevt->evt;
 
         exynos4_mct_tick_clear(mevt);
 
@@ -405,8 +403,7 @@ static int exynos4_local_timer_setup(struct clock_event_device *evt)
         struct mct_clock_event_device *mevt;
         unsigned int cpu = smp_processor_id();
 
-        mevt = this_cpu_ptr(&percpu_mct_tick);
-        mevt->evt = evt;
+        mevt = container_of(evt, struct mct_clock_event_device, evt);
 
         mevt->base = EXYNOS4_MCT_L_BASE(cpu);
         sprintf(mevt->name, "mct_tick%d", cpu);
@@ -448,14 +445,37 @@ static void exynos4_local_timer_stop(struct clock_event_device *evt)
                 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 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 = {
+        .notifier_call = exynos4_mct_cpu_notify,
 };
-#endif /* CONFIG_LOCAL_TIMERS */
 
 static void __init exynos4_timer_resources(struct device_node *np, void __iomem *base)
 {
+        int err;
+        struct mct_clock_event_device *mevt = this_cpu_ptr(&percpu_mct_tick);
         struct clk *mct_clk, *tick_clk;
 
         tick_clk = np ? of_clk_get_by_name(np, "fin_pll") :
@@ -473,9 +493,7 @@ static void __init exynos4_timer_resources(struct device_node *np, void __iomem
         if (!reg_base)
                 panic("%s: unable to ioremap mct address space\n", __func__);
 
-#ifdef CONFIG_LOCAL_TIMERS
         if (mct_int_type == MCT_INT_PPI) {
-                int err;
 
                 err = request_percpu_irq(mct_irqs[MCT_L0_IRQ],
                                          exynos4_mct_tick_isr, "MCT",
@@ -484,8 +502,16 @@ static void __init exynos4_timer_resources(struct device_node *np, void __iomem
                      mct_irqs[MCT_L0_IRQ], err);
         }
 
-        local_timer_register(&exynos4_mct_tick_ops);
-#endif /* CONFIG_LOCAL_TIMERS */
+        err = register_cpu_notifier(&exynos4_mct_cpu_nb);
+        if (err)
+                goto out_irq;
+
+        /* Immediately configure the timer on the boot CPU */
+        exynos4_local_timer_setup(&mevt->evt);
+        return;
+
+out_irq:
+        free_percpu_irq(mct_irqs[MCT_L0_IRQ], &percpu_mct_tick);
 }
 
 void __init mct_init(void __iomem *base, int irq_g0, int irq_l0, int irq_l1)
diff --git a/drivers/clocksource/samsung_pwm_timer.c b/drivers/clocksource/samsung_pwm_timer.c
index 584b5472eea3..ac60f8b8a5f7 100644
--- a/drivers/clocksource/samsung_pwm_timer.c
+++ b/drivers/clocksource/samsung_pwm_timer.c
@@ -44,16 +44,28 @@
 #define TCFG1_SHIFT(x)                  ((x) * 4)
 #define TCFG1_MUX_MASK                  0xf
 
+/*
+ * Each channel occupies 4 bits in TCON register, but there is a gap of 4
+ * bits (one channel) after channel 0, so channels have different numbering
+ * when accessing TCON register.
+ *
+ * In addition, the location of autoreload bit for channel 4 (TCON channel 5)
+ * in its set of bits is 2 as opposed to 3 for other channels.
+ */
 #define TCON_START(chan)                (1 << (4 * (chan) + 0))
 #define TCON_MANUALUPDATE(chan)         (1 << (4 * (chan) + 1))
 #define TCON_INVERT(chan)               (1 << (4 * (chan) + 2))
-#define TCON_AUTORELOAD(chan)           (1 << (4 * (chan) + 3))
+#define _TCON_AUTORELOAD(chan)          (1 << (4 * (chan) + 3))
+#define _TCON_AUTORELOAD4(chan)         (1 << (4 * (chan) + 2))
+#define TCON_AUTORELOAD(chan)           \
+        ((chan < 5) ? _TCON_AUTORELOAD(chan) : _TCON_AUTORELOAD4(chan))
 
 DEFINE_SPINLOCK(samsung_pwm_lock);
 EXPORT_SYMBOL(samsung_pwm_lock);
 
 struct samsung_pwm_clocksource {
         void __iomem *base;
+        void __iomem *source_reg;
         unsigned int irq[SAMSUNG_PWM_NUM];
         struct samsung_pwm_variant variant;
 
@@ -195,17 +207,6 @@ static int samsung_set_next_event(unsigned long cycles,
         return 0;
 }
 
-static void samsung_timer_resume(void)
-{
-        /* event timer restart */
-        samsung_time_setup(pwm.event_id, pwm.clock_count_per_tick - 1);
-        samsung_time_start(pwm.event_id, true);
-
-        /* source timer restart */
-        samsung_time_setup(pwm.source_id, pwm.tcnt_max);
-        samsung_time_start(pwm.source_id, true);
-}
-
 static void samsung_set_mode(enum clock_event_mode mode,
                                 struct clock_event_device *evt)
 {
@@ -222,20 +223,29 @@ static void samsung_set_mode(enum clock_event_mode mode,
 
         case CLOCK_EVT_MODE_UNUSED:
         case CLOCK_EVT_MODE_SHUTDOWN:
-                break;
-
         case CLOCK_EVT_MODE_RESUME:
-                samsung_timer_resume();
                 break;
         }
 }
 
+static void samsung_clockevent_resume(struct clock_event_device *cev)
+{
+        samsung_timer_set_prescale(pwm.event_id, pwm.tscaler_div);
+        samsung_timer_set_divisor(pwm.event_id, pwm.tdiv);
+
+        if (pwm.variant.has_tint_cstat) {
+                u32 mask = (1 << pwm.event_id);
+                writel(mask | (mask << 5), pwm.base + REG_TINT_CSTAT);
+        }
+}
+
 static struct clock_event_device time_event_device = {
         .name           = "samsung_event_timer",
         .features       = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT,
         .rating         = 200,
         .set_next_event = samsung_set_next_event,
         .set_mode       = samsung_set_mode,
+        .resume         = samsung_clockevent_resume,
 };
 
 static irqreturn_t samsung_clock_event_isr(int irq, void *dev_id)
@@ -286,23 +296,34 @@ static void __init samsung_clockevent_init(void)
         }
 }
 
-static void __iomem *samsung_timer_reg(void)
+static void samsung_clocksource_suspend(struct clocksource *cs)
 {
-        switch (pwm.source_id) {
-        case 0:
-        case 1:
-        case 2:
-        case 3:
-                return pwm.base + pwm.source_id * 0x0c + 0x14;
-
-        case 4:
-                return pwm.base + 0x40;
-
-        default:
-                BUG();
-        }
+        samsung_time_stop(pwm.source_id);
 }
 
+static void samsung_clocksource_resume(struct clocksource *cs)
+{
+        samsung_timer_set_prescale(pwm.source_id, pwm.tscaler_div);
+        samsung_timer_set_divisor(pwm.source_id, pwm.tdiv);
+
+        samsung_time_setup(pwm.source_id, pwm.tcnt_max);
+        samsung_time_start(pwm.source_id, true);
+}
+
+static cycle_t samsung_clocksource_read(struct clocksource *c)
+{
+        return ~readl_relaxed(pwm.source_reg);
+}
+
+static struct clocksource samsung_clocksource = {
+        .name           = "samsung_clocksource_timer",
+        .rating         = 250,
+        .read           = samsung_clocksource_read,
+        .suspend        = samsung_clocksource_suspend,
+        .resume         = samsung_clocksource_resume,
+        .flags          = CLOCK_SOURCE_IS_CONTINUOUS,
+};
+
 /*
  * Override the global weak sched_clock symbol with this
  * local implementation which uses the clocksource to get some
@@ -312,17 +333,11 @@ static void __iomem *samsung_timer_reg(void)
  */
 static u32 notrace samsung_read_sched_clock(void)
 {
-        void __iomem *reg = samsung_timer_reg();
-
-        if (!reg)
-                return 0;
-
-        return ~__raw_readl(reg);
+        return samsung_clocksource_read(NULL);
 }
 
 static void __init samsung_clocksource_init(void)
 {
-        void __iomem *reg = samsung_timer_reg();
         unsigned long pclk;
         unsigned long clock_rate;
         int ret;
@@ -337,12 +352,16 @@ static void __init samsung_clocksource_init(void)
         samsung_time_setup(pwm.source_id, pwm.tcnt_max);
         samsung_time_start(pwm.source_id, true);
 
+        if (pwm.source_id == 4)
+                pwm.source_reg = pwm.base + 0x40;
+        else
+                pwm.source_reg = pwm.base + pwm.source_id * 0x0c + 0x14;
+
         setup_sched_clock(samsung_read_sched_clock,
                                                 pwm.variant.bits, clock_rate);
 
-        ret = clocksource_mmio_init(reg, "samsung_clocksource_timer",
-                                        clock_rate, 250, pwm.variant.bits,
-                                        clocksource_mmio_readl_down);
+        samsung_clocksource.mask = CLOCKSOURCE_MASK(pwm.variant.bits);
+        ret = clocksource_register_hz(&samsung_clocksource, clock_rate);
         if (ret)
                 panic("samsung_clocksource_timer: can't register clocksource\n");
 }
@@ -404,7 +423,6 @@ void __init samsung_pwm_clocksource_init(void __iomem *base,
 static void __init samsung_pwm_alloc(struct device_node *np,
                                      const struct samsung_pwm_variant *variant)
 {
-        struct resource res;
         struct property *prop;
         const __be32 *cur;
         u32 val;
@@ -423,17 +441,9 @@ static void __init samsung_pwm_alloc(struct device_node *np,
                 pwm.variant.output_mask |= 1 << val;
         }
 
-        of_address_to_resource(np, 0, &res);
-        if (!request_mem_region(res.start,
-                                resource_size(&res), "samsung-pwm")) {
-                pr_err("%s: failed to request IO mem region\n", __func__);
-                return;
-        }
-
-        pwm.base = ioremap(res.start, resource_size(&res));
+        pwm.base = of_iomap(np, 0);
         if (!pwm.base) {
                 pr_err("%s: failed to map PWM registers\n", __func__);
-                release_mem_region(res.start, resource_size(&res));
                 return;
         }
 
diff --git a/drivers/clocksource/time-armada-370-xp.c b/drivers/clocksource/time-armada-370-xp.c
index 1b04b7e1d39b..847cab6f6e31 100644
--- a/drivers/clocksource/time-armada-370-xp.c
+++ b/drivers/clocksource/time-armada-370-xp.c
@@ -19,6 +19,7 @@
 #include <linux/platform_device.h>
 #include <linux/kernel.h>
 #include <linux/clk.h>
+#include <linux/cpu.h>
 #include <linux/timer.h>
 #include <linux/clockchips.h>
 #include <linux/interrupt.h>
@@ -28,9 +29,9 @@
 #include <linux/irq.h>
 #include <linux/module.h>
 #include <linux/sched_clock.h>
-
-#include <asm/localtimer.h>
 #include <linux/percpu.h>
+#include <linux/time-armada-370-xp.h>
+
 /*
  * Timer block registers.
  */
@@ -69,7 +70,7 @@ static bool timer25Mhz = true;
  */
 static u32 ticks_per_jiffy;
 
-static struct clock_event_device __percpu **percpu_armada_370_xp_evt;
+static struct clock_event_device __percpu *armada_370_xp_evt;
 
 static u32 notrace armada_370_xp_read_sched_clock(void)
 {
@@ -142,21 +143,14 @@ armada_370_xp_clkevt_mode(enum clock_event_mode mode,
         }
 }
 
-static struct clock_event_device armada_370_xp_clkevt = {
-        .name           = "armada_370_xp_per_cpu_tick",
-        .features       = CLOCK_EVT_FEAT_ONESHOT | CLOCK_EVT_FEAT_PERIODIC,
-        .shift          = 32,
-        .rating         = 300,
-        .set_next_event = armada_370_xp_clkevt_next_event,
-        .set_mode       = armada_370_xp_clkevt_mode,
-};
+static int armada_370_xp_clkevt_irq;
 
 static irqreturn_t armada_370_xp_timer_interrupt(int irq, void *dev_id)
 {
         /*
          * ACK timer interrupt and call event handler.
          */
-        struct clock_event_device *evt = *(struct clock_event_device **)dev_id;
+        struct clock_event_device *evt = dev_id;
 
         writel(TIMER0_CLR_MASK, local_base + LCL_TIMER_EVENTS_STATUS);
         evt->event_handler(evt);
@@ -172,42 +166,55 @@ static int armada_370_xp_timer_setup(struct clock_event_device *evt)
         u32 u;
         int cpu = smp_processor_id();
 
-        /* Use existing clock_event for cpu 0 */
-        if (!smp_processor_id())
-                return 0;
-
         u = readl(local_base + TIMER_CTRL_OFF);
         if (timer25Mhz)
                 writel(u | TIMER0_25MHZ, local_base + TIMER_CTRL_OFF);
         else
                 writel(u & ~TIMER0_25MHZ, local_base + TIMER_CTRL_OFF);
 
-        evt->name               = armada_370_xp_clkevt.name;
-        evt->irq                = armada_370_xp_clkevt.irq;
-        evt->features           = armada_370_xp_clkevt.features;
-        evt->shift              = armada_370_xp_clkevt.shift;
-        evt->rating             = armada_370_xp_clkevt.rating,
+        evt->name               = "armada_370_xp_per_cpu_tick",
+        evt->features           = CLOCK_EVT_FEAT_ONESHOT |
+                                  CLOCK_EVT_FEAT_PERIODIC;
+        evt->shift              = 32,
+        evt->rating             = 300,
         evt->set_next_event     = armada_370_xp_clkevt_next_event,
         evt->set_mode           = armada_370_xp_clkevt_mode,
+        evt->irq                = armada_370_xp_clkevt_irq;
         evt->cpumask            = cpumask_of(cpu);
 
-        *__this_cpu_ptr(percpu_armada_370_xp_evt) = evt;
-
         clockevents_config_and_register(evt, timer_clk, 1, 0xfffffffe);
         enable_percpu_irq(evt->irq, 0);
 
         return 0;
 }
 
-static void  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 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 = {
+        .notifier_call = armada_370_xp_timer_cpu_notify,
 };
 
 void __init armada_370_xp_timer_init(void)
@@ -223,9 +230,6 @@ void __init armada_370_xp_timer_init(void)
 
         if (of_find_property(np, "marvell,timer-25Mhz", NULL)) {
                 /* The fixed 25MHz timer is available so let's use it */
-                u = readl(local_base + TIMER_CTRL_OFF);
-                writel(u | TIMER0_25MHZ,
-                       local_base + TIMER_CTRL_OFF);
                 u = readl(timer_base + TIMER_CTRL_OFF);
                 writel(u | TIMER0_25MHZ,
                        timer_base + TIMER_CTRL_OFF);
@@ -235,9 +239,6 @@ void __init armada_370_xp_timer_init(void)
                 struct clk *clk = of_clk_get(np, 0);
                 WARN_ON(IS_ERR(clk));
                 rate =  clk_get_rate(clk);
-                u = readl(local_base + TIMER_CTRL_OFF);
-                writel(u & ~(TIMER0_25MHZ),
-                       local_base + TIMER_CTRL_OFF);
 
                 u = readl(timer_base + TIMER_CTRL_OFF);
                 writel(u & ~(TIMER0_25MHZ),
@@ -251,7 +252,7 @@ void __init armada_370_xp_timer_init(void)
          * We use timer 0 as clocksource, and private(local) timer 0
          * for clockevents
          */
-        armada_370_xp_clkevt.irq = irq_of_parse_and_map(np, 4);
+        armada_370_xp_clkevt_irq = irq_of_parse_and_map(np, 4);
 
         ticks_per_jiffy = (timer_clk + HZ / 2) / HZ;
 
@@ -276,26 +277,19 @@ void __init armada_370_xp_timer_init(void)
                               "armada_370_xp_clocksource",
                               timer_clk, 300, 32, clocksource_mmio_readl_down);
 
-        /* Register the clockevent on the private timer of CPU 0 */
-        armada_370_xp_clkevt.cpumask = cpumask_of(0);
-        clockevents_config_and_register(&armada_370_xp_clkevt,
-                                        timer_clk, 1, 0xfffffffe);
+        register_cpu_notifier(&armada_370_xp_timer_cpu_nb);
 
-        percpu_armada_370_xp_evt = alloc_percpu(struct clock_event_device *);
+        armada_370_xp_evt = alloc_percpu(struct clock_event_device);
 
 
         /*
          * Setup clockevent timer (interrupt-driven).
          */
-        *__this_cpu_ptr(percpu_armada_370_xp_evt) = &armada_370_xp_clkevt;
-        res = request_percpu_irq(armada_370_xp_clkevt.irq,
+        res = request_percpu_irq(armada_370_xp_clkevt_irq,
                                 armada_370_xp_timer_interrupt,
-                                armada_370_xp_clkevt.name,
-                                percpu_armada_370_xp_evt);
-        if (!res) {
-                enable_percpu_irq(armada_370_xp_clkevt.irq, 0);
-#ifdef CONFIG_LOCAL_TIMERS
-                local_timer_register(&armada_370_xp_local_timer_ops);
-#endif
-        }
+                                "armada_370_xp_per_cpu_tick",
+                                armada_370_xp_evt);
+        /* Immediately configure the timer on the boot CPU */
+        if (!res)
+                armada_370_xp_timer_setup(this_cpu_ptr(armada_370_xp_evt));
 }
diff --git a/drivers/clocksource/timer-marco.c b/drivers/clocksource/timer-marco.c
index 62876baa3ab9..09a17d9a6594 100644
--- a/drivers/clocksource/timer-marco.c
+++ b/drivers/clocksource/timer-marco.c
@@ -10,6 +10,7 @@
 #include <linux/interrupt.h>
 #include <linux/clockchips.h>
 #include <linux/clocksource.h>
+#include <linux/cpu.h>
 #include <linux/bitops.h>
 #include <linux/irq.h>
 #include <linux/clk.h>
@@ -18,7 +19,6 @@
 #include <linux/of_irq.h>
 #include <linux/of_address.h>
 #include <linux/sched_clock.h>
-#include <asm/localtimer.h>
 #include <asm/mach/time.h>
 
 #define SIRFSOC_TIMER_32COUNTER_0_CTRL                  0x0000
@@ -151,13 +151,7 @@ static void sirfsoc_clocksource_resume(struct clocksource *cs)
                 BIT(1) | BIT(0), sirfsoc_timer_base + SIRFSOC_TIMER_64COUNTER_CTRL);
 }
 
-static struct clock_event_device sirfsoc_clockevent = {
-        .name = "sirfsoc_clockevent",
-        .rating = 200,
-        .features = CLOCK_EVT_FEAT_ONESHOT,
-        .set_mode = sirfsoc_timer_set_mode,
-        .set_next_event = sirfsoc_timer_set_next_event,
-};
+static struct clock_event_device __percpu *sirfsoc_clockevent;
 
 static struct clocksource sirfsoc_clocksource = {
         .name = "sirfsoc_clocksource",
@@ -173,11 +167,8 @@ static struct irqaction sirfsoc_timer_irq = {
         .name = "sirfsoc_timer0",
         .flags = IRQF_TIMER | IRQF_NOBALANCING,
         .handler = sirfsoc_timer_interrupt,
-        .dev_id = &sirfsoc_clockevent,
 };
 
-#ifdef CONFIG_LOCAL_TIMERS
-
 static struct irqaction sirfsoc_timer1_irq = {
         .name = "sirfsoc_timer1",
         .flags = IRQF_TIMER | IRQF_NOBALANCING,
@@ -186,24 +177,28 @@ static struct irqaction sirfsoc_timer1_irq = {
 
 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;
@@ -211,31 +206,48 @@ static int sirfsoc_local_timer_setup(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 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 = {
+        .notifier_call = sirfsoc_cpu_notify,
 };
-#endif /* CONFIG_LOCAL_TIMERS */
 
 static void __init sirfsoc_clockevent_init(void)
 {
-        clockevents_calc_mult_shift(&sirfsoc_clockevent, CLOCK_TICK_RATE, 60);
-
-        sirfsoc_clockevent.max_delta_ns =
-                clockevent_delta2ns(-2, &sirfsoc_clockevent);
-        sirfsoc_clockevent.min_delta_ns =
-                clockevent_delta2ns(2, &sirfsoc_clockevent);
-
-        sirfsoc_clockevent.cpumask = cpumask_of(0);
-        clockevents_register_device(&sirfsoc_clockevent);
-#ifdef CONFIG_LOCAL_TIMERS
-        local_timer_register(&sirfsoc_local_timer_ops);
-#endif
+        sirfsoc_clockevent = alloc_percpu(struct clock_event_device);
+        BUG_ON(!sirfsoc_clockevent);
+
+        BUG_ON(register_cpu_notifier(&sirfsoc_cpu_nb));
+
+        /* Immediately configure the timer on the boot CPU */
+        sirfsoc_local_timer_setup(this_cpu_ptr(sirfsoc_clockevent));
 }
 
 /* initialize the kernel jiffy timer source */
@@ -273,8 +285,6 @@ static void __init sirfsoc_marco_timer_init(void)
 
         BUG_ON(clocksource_register_hz(&sirfsoc_clocksource, CLOCK_TICK_RATE));
 
-        BUG_ON(setup_irq(sirfsoc_timer_irq.irq, &sirfsoc_timer_irq));
-
         sirfsoc_clockevent_init();
 }
 
@@ -288,11 +298,9 @@ static void __init sirfsoc_of_timer_init(struct device_node *np)
         if (!sirfsoc_timer_irq.irq)
                 panic("No irq passed for timer0 via DT\n");
 
-#ifdef CONFIG_LOCAL_TIMERS
         sirfsoc_timer1_irq.irq = irq_of_parse_and_map(np, 1);
         if (!sirfsoc_timer1_irq.irq)
                 panic("No irq passed for timer1 via DT\n");
-#endif
 
         sirfsoc_marco_timer_init();
 }