111 files changed, 2460 insertions, 1208 deletions
diff --git a/Documentation/devicetree/bindings/timer/oxsemi,rps-timer.txt b/Documentation/devicetree/bindings/timer/oxsemi,rps-timer.txt
new file mode 100644
index 000000000000..3ca89cd1caef
--- /dev/null
+++ b/Documentation/devicetree/bindings/timer/oxsemi,rps-timer.txt
@@ -0,0 +1,17 @@
+Oxford Semiconductor OXNAS SoCs Family RPS Timer
+================================================
+Required properties:
+- compatible: Should be "oxsemi,ox810se-rps-timer"
+- reg : Specifies base physical address and size of the registers.
+- interrupts : The interrupts of the two timers
+- clocks : The phandle of the timer clock source
+example:
+timer0: timer@200 {
+        compatible = "oxsemi,ox810se-rps-timer";
+        reg = <0x200 0x40>;
+        clocks = <&rpsclk>;
+        interrupts = <4 5>;
+};
diff --git a/Documentation/devicetree/bindings/timer/rockchip,rk3288-timer.txt b/Documentation/devicetree/bindings/timer/rockchip,rk-timer.txt
index 87f0b0042bae..a41b184d5538 100644
--- a/Documentation/devicetree/bindings/timer/rockchip,rk3288-timer.txt
+++ b/Documentation/devicetree/bindings/timer/rockchip,rk-timer.txt
@@ -1,7 +1,9 @@
-Rockchip rk3288 timer
+Rockchip rk timer
 Required properties:
- compatible: shall be "rockchip,rk3288-timer"
+- compatible: shall be one of:
+  "rockchip,rk3288-timer" - for rk3066, rk3036, rk3188, rk322x, rk3288, rk3368
+  "rockchip,rk3399-timer" - for rk3399
 - reg: base address of the timer register starting with TIMERS CONTROL register
 - interrupts: should contain the interrupts for Timer0
 - clocks : must contain an entry for each entry in clock-names
diff --git a/Documentation/kernel-parameters.txt b/Documentation/kernel-parameters.txt
index fa8c6d470ad2..17e33dbbf226 100644
--- a/Documentation/kernel-parameters.txt
+++ b/Documentation/kernel-parameters.txt
@@ -687,6 +687,14 @@ bytes respectively. Such letter suffixes can also be entirely omitted.
                        [SPARC64] tick
                        [X86-64] hpet,tsc
+        clocksource.arm_arch_timer.evtstrm=
+                        [ARM,ARM64]
+                        Format: <bool>
+                        Enable/disable the eventstream feature of the ARM
+                        architected timer so that code using WFE-based polling
+                        loops can be debugged more effectively on production
+                        systems.
        clearcpuid=BITNUM [X86]
                        Disable CPUID feature X for the kernel. See
                        arch/x86/include/asm/cpufeatures.h for the valid bit
diff --git a/arch/arc/kernel/time.c b/arch/arc/kernel/time.c
index 4549ab255dd1..98f22d2eb563 100644
--- a/arch/arc/kernel/time.c
+++ b/arch/arc/kernel/time.c
@@ -116,19 +116,19 @@ static struct clocksource arc_counter_gfrc = {
        .flags  = CLOCK_SOURCE_IS_CONTINUOUS,
 };
-static void __init arc_cs_setup_gfrc(struct device_node *node)
+static int __init arc_cs_setup_gfrc(struct device_node *node)
 {
        int exists = cpuinfo_arc700[0].extn.gfrc;
        int ret;
        if (WARN(!exists, "Global-64-bit-Ctr clocksource not detected"))
-                return;
+                return -ENXIO;
        ret = arc_get_timer_clk(node);
        if (ret)
-                return;
+                return ret;
-        clocksource_register_hz(&arc_counter_gfrc, arc_timer_freq);
+        return clocksource_register_hz(&arc_counter_gfrc, arc_timer_freq);
 }
 CLOCKSOURCE_OF_DECLARE(arc_gfrc, "snps,archs-timer-gfrc", arc_cs_setup_gfrc);
@@ -172,25 +172,25 @@ static struct clocksource arc_counter_rtc = {
        .flags  = CLOCK_SOURCE_IS_CONTINUOUS,
 };
-static void __init arc_cs_setup_rtc(struct device_node *node)
+static int __init arc_cs_setup_rtc(struct device_node *node)
 {
        int exists = cpuinfo_arc700[smp_processor_id()].extn.rtc;
        int ret;
        if (WARN(!exists, "Local-64-bit-Ctr clocksource not detected"))
-                return;
+                return -ENXIO;
        /* Local to CPU hence not usable in SMP */
        if (WARN(IS_ENABLED(CONFIG_SMP), "Local-64-bit-Ctr not usable in SMP"))
-                return;
+                return -EINVAL;
        ret = arc_get_timer_clk(node);
        if (ret)
-                return;
+                return ret;
        write_aux_reg(AUX_RTC_CTRL, 1);
-        clocksource_register_hz(&arc_counter_rtc, arc_timer_freq);
+        return clocksource_register_hz(&arc_counter_rtc, arc_timer_freq);
 }
 CLOCKSOURCE_OF_DECLARE(arc_rtc, "snps,archs-timer-rtc", arc_cs_setup_rtc);
@@ -213,23 +213,23 @@ static struct clocksource arc_counter_timer1 = {
        .flags  = CLOCK_SOURCE_IS_CONTINUOUS,
 };
-static void __init arc_cs_setup_timer1(struct device_node *node)
+static int __init arc_cs_setup_timer1(struct device_node *node)
 {
        int ret;
        /* Local to CPU hence not usable in SMP */
        if (IS_ENABLED(CONFIG_SMP))
-                return;
+                return -EINVAL;
        ret = arc_get_timer_clk(node);
        if (ret)
-                return;
+                return ret;
        write_aux_reg(ARC_REG_TIMER1_LIMIT, ARC_TIMER_MAX);
        write_aux_reg(ARC_REG_TIMER1_CNT, 0);
        write_aux_reg(ARC_REG_TIMER1_CTRL, TIMER_CTRL_NH);
-        clocksource_register_hz(&arc_counter_timer1, arc_timer_freq);
+        return clocksource_register_hz(&arc_counter_timer1, arc_timer_freq);
 }
 /********** Clock Event Device *********/
@@ -324,20 +324,28 @@ static struct notifier_block arc_timer_cpu_nb = {
 /*
 * clockevent setup for boot CPU
 */
-static void __init arc_clockevent_setup(struct device_node *node)
+static int __init arc_clockevent_setup(struct device_node *node)
 {
        struct clock_event_device *evt = this_cpu_ptr(&arc_clockevent_device);
        int ret;
-        register_cpu_notifier(&arc_timer_cpu_nb);
+        ret = register_cpu_notifier(&arc_timer_cpu_nb);
+        if (ret) {
+                pr_err("Failed to register cpu notifier");
+                return ret;
+        }
        arc_timer_irq = irq_of_parse_and_map(node, 0);
-        if (arc_timer_irq <= 0)
+        if (arc_timer_irq <= 0) {
-                panic("clockevent: missing irq");
+                pr_err("clockevent: missing irq");
+                return -EINVAL;
+        }
        ret = arc_get_timer_clk(node);
-        if (ret)
+        if (ret) {
-                panic("clockevent: missing clk");
+                pr_err("clockevent: missing clk");
+                return ret;
+        }
        evt->irq = arc_timer_irq;
        evt->cpumask = cpumask_of(smp_processor_id());
@@ -347,22 +355,29 @@ static void __init arc_clockevent_setup(struct device_node *node)
        /* 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)
+        if (ret) {
-                panic("clockevent: unable to request irq\n");
+                pr_err("clockevent: unable to request irq\n");
+                return ret;
+        }
        enable_percpu_irq(arc_timer_irq, 0);
+        return 0;
 }
-static void __init arc_of_timer_init(struct device_node *np)
+static int __init arc_of_timer_init(struct device_node *np)
 {
        static int init_count = 0;
+        int ret;
        if (!init_count) {
                init_count = 1;
-                arc_clockevent_setup(np);
+                ret = arc_clockevent_setup(np);
        } else {
-                arc_cs_setup_timer1(np);
+                ret = arc_cs_setup_timer1(np);
        }
+        return ret;
 }
 CLOCKSOURCE_OF_DECLARE(arc_clkevt, "snps,arc-timer", arc_of_timer_init);
diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig
index 90542db1220d..f0636ec94903 100644
--- a/arch/arm/Kconfig
+++ b/arch/arm/Kconfig
@@ -358,10 +358,10 @@ config ARCH_CLPS711X
        bool "Cirrus Logic CLPS711x/EP721x/EP731x-based"
        select ARCH_REQUIRE_GPIOLIB
        select AUTO_ZRELADDR
-        select CLKSRC_MMIO
        select COMMON_CLK
        select CPU_ARM720T
        select GENERIC_CLOCKEVENTS
+        select CLPS711X_TIMER
        select MFD_SYSCON
        select SOC_BUS
        help
diff --git a/arch/arm/kernel/smp_twd.c b/arch/arm/kernel/smp_twd.c
index 1bfa7a7f5533..b6ec65e68009 100644
--- a/arch/arm/kernel/smp_twd.c
+++ b/arch/arm/kernel/smp_twd.c
@@ -390,7 +390,7 @@ int __init twd_local_timer_register(struct twd_local_timer *tlt)
 }
 #ifdef CONFIG_OF
-static void __init twd_local_timer_of_register(struct device_node *np)
+static int __init twd_local_timer_of_register(struct device_node *np)
 {
        int err;
@@ -410,6 +410,7 @@ static void __init twd_local_timer_of_register(struct device_node *np)
 out:
        WARN(err, "twd_local_timer_of_register failed (%d)\n", err);
+        return err;
 }
 CLOCKSOURCE_OF_DECLARE(arm_twd_a9, "arm,cortex-a9-twd-timer", twd_local_timer_of_register);
 CLOCKSOURCE_OF_DECLARE(arm_twd_a5, "arm,cortex-a5-twd-timer", twd_local_timer_of_register);
diff --git a/arch/arm/mach-bcm/Kconfig b/arch/arm/mach-bcm/Kconfig
index 68ab6412392a..4f1709b31822 100644
--- a/arch/arm/mach-bcm/Kconfig
+++ b/arch/arm/mach-bcm/Kconfig
@@ -89,6 +89,7 @@ config ARCH_BCM_MOBILE
        select HAVE_ARM_ARCH_TIMER
        select PINCTRL
        select ARCH_BCM_MOBILE_SMP if SMP
+        select BCM_KONA_TIMER
        help
          This enables support for systems based on Broadcom mobile SoCs.
@@ -143,6 +144,7 @@ config ARCH_BCM2835
        select ARM_TIMER_SP804
        select HAVE_ARM_ARCH_TIMER if ARCH_MULTI_V7
        select CLKSRC_OF
+        select BCM2835_TIMER
        select PINCTRL
        select PINCTRL_BCM2835
        help
diff --git a/arch/arm/mach-integrator/Kconfig b/arch/arm/mach-integrator/Kconfig
index b2a85ba13f08..291262e5aeaf 100644
--- a/arch/arm/mach-integrator/Kconfig
+++ b/arch/arm/mach-integrator/Kconfig
@@ -20,7 +20,7 @@ if ARCH_INTEGRATOR
 config ARCH_INTEGRATOR_AP
        bool "Support Integrator/AP and Integrator/PP2 platforms"
-        select CLKSRC_MMIO
+        select INTEGRATOR_AP_TIMER
        select MIGHT_HAVE_PCI
        select SERIAL_AMBA_PL010 if TTY
        select SERIAL_AMBA_PL010_CONSOLE if TTY
diff --git a/arch/arm/mach-keystone/Kconfig b/arch/arm/mach-keystone/Kconfig
index ea955f6db8b7..bac577badc7e 100644
--- a/arch/arm/mach-keystone/Kconfig
+++ b/arch/arm/mach-keystone/Kconfig
@@ -4,7 +4,7 @@ config ARCH_KEYSTONE
        depends on ARM_PATCH_PHYS_VIRT
        select ARM_GIC
        select HAVE_ARM_ARCH_TIMER
-        select CLKSRC_MMIO
+        select KEYSTONE_TIMER
        select ARM_ERRATA_798181 if SMP
        select COMMON_CLK_KEYSTONE
        select ARCH_SUPPORTS_BIG_ENDIAN
diff --git a/arch/arm/mach-moxart/Kconfig b/arch/arm/mach-moxart/Kconfig
index 180d9d216719..ddc79cea32d3 100644
--- a/arch/arm/mach-moxart/Kconfig
+++ b/arch/arm/mach-moxart/Kconfig
@@ -3,7 +3,7 @@ menuconfig ARCH_MOXART
        depends on ARCH_MULTI_V4
        select CPU_FA526
        select ARM_DMA_MEM_BUFFERABLE
-        select CLKSRC_MMIO
+        select MOXART_TIMER
        select GENERIC_IRQ_CHIP
        select ARCH_REQUIRE_GPIOLIB
        select PHYLIB if NETDEVICES
diff --git a/arch/arm/mach-mxs/Kconfig b/arch/arm/mach-mxs/Kconfig
index 84794137b175..68a3a9ec605d 100644
--- a/arch/arm/mach-mxs/Kconfig
+++ b/arch/arm/mach-mxs/Kconfig
@@ -16,7 +16,7 @@ config ARCH_MXS
        bool "Freescale MXS (i.MX23, i.MX28) support"
        depends on ARCH_MULTI_V5
        select ARCH_REQUIRE_GPIOLIB
-        select CLKSRC_MMIO
+        select MXS_TIMER
        select PINCTRL
        select SOC_BUS
        select SOC_IMX23
diff --git a/arch/arm/mach-nspire/Kconfig b/arch/arm/mach-nspire/Kconfig
index bc41f26c1a12..d4985305cab2 100644
--- a/arch/arm/mach-nspire/Kconfig
+++ b/arch/arm/mach-nspire/Kconfig
@@ -7,5 +7,6 @@ config ARCH_NSPIRE
        select ARM_AMBA
        select ARM_VIC
        select ARM_TIMER_SP804
+        select NSPIRE_TIMER
        help
          This enables support for systems using the TI-NSPIRE CPU
diff --git a/arch/arm/mach-prima2/Kconfig b/arch/arm/mach-prima2/Kconfig
index 0cf4426183cf..9e938f2961cf 100644
--- a/arch/arm/mach-prima2/Kconfig
+++ b/arch/arm/mach-prima2/Kconfig
@@ -28,6 +28,7 @@ config ARCH_ATLAS7
        default y
        select ARM_GIC
        select CPU_V7
+        select ATLAS7_TIMER
        select HAVE_ARM_SCU if SMP
        select HAVE_SMP
        help
@@ -38,6 +39,7 @@ config ARCH_PRIMA2
        default y
        select SIRF_IRQ
        select ZONE_DMA
+        select PRIMA2_TIMER
        help
          Support for CSR SiRFSoC ARM Cortex A9 Platform
diff --git a/arch/arm/mach-u300/Kconfig b/arch/arm/mach-u300/Kconfig
index 301a98498453..4fdc3425ffbd 100644
--- a/arch/arm/mach-u300/Kconfig
+++ b/arch/arm/mach-u300/Kconfig
@@ -4,7 +4,7 @@ menuconfig ARCH_U300
        select ARCH_REQUIRE_GPIOLIB
        select ARM_AMBA
        select ARM_VIC
-        select CLKSRC_MMIO
+        select U300_TIMER
        select CPU_ARM926T
        select HAVE_TCM
        select PINCTRL
diff --git a/arch/arm64/boot/dts/rockchip/rk3399.dtsi b/arch/arm64/boot/dts/rockchip/rk3399.dtsi
index d7f8e06910bc..188bbeab92b9 100644
--- a/arch/arm64/boot/dts/rockchip/rk3399.dtsi
+++ b/arch/arm64/boot/dts/rockchip/rk3399.dtsi
@@ -492,6 +492,14 @@
                interrupts = <GIC_SPI 120 IRQ_TYPE_LEVEL_HIGH>;
        };
+        rktimer: rktimer@ff850000 {
+                compatible = "rockchip,rk3399-timer";
+                reg = <0x0 0xff850000 0x0 0x1000>;
+                interrupts = <GIC_SPI 81 IRQ_TYPE_LEVEL_HIGH>;
+                clocks = <&cru PCLK_TIMER0>, <&cru SCLK_TIMER00>;
+                clock-names = "pclk", "timer";
+        };
        spdif: spdif@ff870000 {
                compatible = "rockchip,rk3399-spdif";
                reg = <0x0 0xff870000 0x0 0x1000>;
diff --git a/arch/microblaze/kernel/timer.c b/arch/microblaze/kernel/timer.c
index 67e2ef48d2d0..5bbf38b916ef 100644
--- a/arch/microblaze/kernel/timer.c
+++ b/arch/microblaze/kernel/timer.c
@@ -170,7 +170,7 @@ static struct irqaction timer_irqaction = {
        .dev_id = &clockevent_xilinx_timer,
 };
-static __init void xilinx_clockevent_init(void)
+static __init int xilinx_clockevent_init(void)
 {
        clockevent_xilinx_timer.mult =
                div_sc(timer_clock_freq, NSEC_PER_SEC,
@@ -181,6 +181,8 @@ static __init void xilinx_clockevent_init(void)
                clockevent_delta2ns(1, &clockevent_xilinx_timer);
        clockevent_xilinx_timer.cpumask = cpumask_of(0);
        clockevents_register_device(&clockevent_xilinx_timer);
+        return 0;
 }
 static u64 xilinx_clock_read(void)
@@ -229,8 +231,14 @@ static struct clocksource clocksource_microblaze = {
 static int __init xilinx_clocksource_init(void)
 {
-        if (clocksource_register_hz(&clocksource_microblaze, timer_clock_freq))
+        int ret;
-                panic("failed to register clocksource");
+        ret = clocksource_register_hz(&clocksource_microblaze,
+                                      timer_clock_freq);
+        if (ret) {
+                pr_err("failed to register clocksource");
+                return ret;
+        }
        /* stop timer1 */
        write_fn(read_fn(timer_baseaddr + TCSR1) & ~TCSR_ENT,
@@ -239,16 +247,16 @@ static int __init xilinx_clocksource_init(void)
        write_fn(TCSR_TINT|TCSR_ENT|TCSR_ARHT, timer_baseaddr + TCSR1);
        /* register timecounter - for ftrace support */
-        init_xilinx_timecounter();
+        return init_xilinx_timecounter();
-        return 0;
 }
-static void __init xilinx_timer_init(struct device_node *timer)
+static int __init xilinx_timer_init(struct device_node *timer)
 {
        struct clk *clk;
        static int initialized;
        u32 irq;
        u32 timer_num = 1;
+        int ret;
        if (initialized)
                return;
@@ -258,7 +266,7 @@ static void __init xilinx_timer_init(struct device_node *timer)
        timer_baseaddr = of_iomap(timer, 0);
        if (!timer_baseaddr) {
                pr_err("ERROR: invalid timer base address\n");
-                BUG();
+                return -ENXIO;
        }
        write_fn = timer_write32;
@@ -271,11 +279,15 @@ static void __init xilinx_timer_init(struct device_node *timer)
        }
        irq = irq_of_parse_and_map(timer, 0);
+        if (irq <= 0) {
+                pr_err("Failed to parse and map irq");
+                return -EINVAL;
+        }
        of_property_read_u32(timer, "xlnx,one-timer-only", &timer_num);
        if (timer_num) {
-                pr_emerg("Please enable two timers in HW\n");
+                pr_err("Please enable two timers in HW\n");
-                BUG();
+                return -EINVAL;
        }
        pr_info("%s: irq=%d\n", timer->full_name, irq);
@@ -297,14 +309,27 @@ static void __init xilinx_timer_init(struct device_node *timer)
        freq_div_hz = timer_clock_freq / HZ;
-        setup_irq(irq, &timer_irqaction);
+        ret = setup_irq(irq, &timer_irqaction);
+        if (ret) {
+                pr_err("Failed to setup IRQ");
+                return ret;
+        }
 #ifdef CONFIG_HEART_BEAT
        microblaze_setup_heartbeat();
 #endif
-        xilinx_clocksource_init();
-        xilinx_clockevent_init();
+        ret = xilinx_clocksource_init();
+        if (ret)
+                return ret;
+        ret = xilinx_clockevent_init();
+        if (ret)
+                return ret;
        sched_clock_register(xilinx_clock_read, 32, timer_clock_freq);
+        return 0;
 }
 CLOCKSOURCE_OF_DECLARE(xilinx_timer, "xlnx,xps-timer-1.00.a",
diff --git a/arch/mips/ralink/cevt-rt3352.c b/arch/mips/ralink/cevt-rt3352.c
index 3ad0b0794f7d..f24eee04e16a 100644
--- a/arch/mips/ralink/cevt-rt3352.c
+++ b/arch/mips/ralink/cevt-rt3352.c
@@ -117,11 +117,13 @@ static int systick_set_oneshot(struct clock_event_device *evt)
        return 0;
 }
-static void __init ralink_systick_init(struct device_node *np)
+static int __init ralink_systick_init(struct device_node *np)
 {
+        int ret;
        systick.membase = of_iomap(np, 0);
        if (!systick.membase)
-                return;
+                return -ENXIO;
        systick_irqaction.name = np->name;
        systick.dev.name = np->name;
@@ -131,16 +133,21 @@ static void __init ralink_systick_init(struct device_node *np)
        systick.dev.irq = irq_of_parse_and_map(np, 0);
        if (!systick.dev.irq) {
                pr_err("%s: request_irq failed", np->name);
-                return;
+                return -EINVAL;
        }
-        clocksource_mmio_init(systick.membase + SYSTICK_COUNT, np->name,
+        ret = clocksource_mmio_init(systick.membase + SYSTICK_COUNT, np->name,
-                        SYSTICK_FREQ, 301, 16, clocksource_mmio_readl_up);
+                                    SYSTICK_FREQ, 301, 16,
+                                    clocksource_mmio_readl_up);
+        if (ret)
+                return ret;
        clockevents_register_device(&systick.dev);
        pr_info("%s: running - mult: %d, shift: %d\n",
                        np->name, systick.dev.mult, systick.dev.shift);
+        return 0;
 }
 CLOCKSOURCE_OF_DECLARE(systick, "ralink,cevt-systick", ralink_systick_init);
diff --git a/arch/nios2/kernel/time.c b/arch/nios2/kernel/time.c
index e835dda2bfe2..d9563ddb337e 100644
--- a/arch/nios2/kernel/time.c
+++ b/arch/nios2/kernel/time.c
@@ -206,15 +206,21 @@ irqreturn_t timer_interrupt(int irq, void *dev_id)
        return IRQ_HANDLED;
 }
-static void __init nios2_timer_get_base_and_freq(struct device_node *np,
+static int __init nios2_timer_get_base_and_freq(struct device_node *np,
                                void __iomem **base, u32 *freq)
 {
        *base = of_iomap(np, 0);
-        if (!*base)
+        if (!*base) {
-                panic("Unable to map reg for %s\n", np->name);
+                pr_crit("Unable to map reg for %s\n", np->name);
+                return -ENXIO;
+        }
+        if (of_property_read_u32(np, "clock-frequency", freq)) {
+                pr_crit("Unable to get %s clock frequency\n", np->name);
+                return -EINVAL;
+        }
-        if (of_property_read_u32(np, "clock-frequency", freq))
+        return 0;
-                panic("Unable to get %s clock frequency\n", np->name);
 }
 static struct nios2_clockevent_dev nios2_ce = {
@@ -231,17 +237,21 @@ static struct nios2_clockevent_dev nios2_ce = {
        },
 };
-static __init void nios2_clockevent_init(struct device_node *timer)
+static __init int nios2_clockevent_init(struct device_node *timer)
 {
        void __iomem *iobase;
        u32 freq;
-        int irq;
+        int irq, ret;
-        nios2_timer_get_base_and_freq(timer, &iobase, &freq);
+        ret = nios2_timer_get_base_and_freq(timer, &iobase, &freq);
+        if (ret)
+                return ret;
        irq = irq_of_parse_and_map(timer, 0);
-        if (!irq)
+        if (!irq) {
-                panic("Unable to parse timer irq\n");
+                pr_crit("Unable to parse timer irq\n");
+                return -EINVAL;
+        }
        nios2_ce.timer.base = iobase;
        nios2_ce.timer.freq = freq;
@@ -253,25 +263,35 @@ static __init void nios2_clockevent_init(struct device_node *timer)
        /* clear pending interrupt */
        timer_writew(&nios2_ce.timer, 0, ALTERA_TIMER_STATUS_REG);
-        if (request_irq(irq, timer_interrupt, IRQF_TIMER, timer->name,
+        ret = request_irq(irq, timer_interrupt, IRQF_TIMER, timer->name,
-                &nios2_ce.ced))
+                          &nios2_ce.ced);
-                panic("Unable to setup timer irq\n");
+        if (ret) {
+                pr_crit("Unable to setup timer irq\n");
+                return ret;
+        }
        clockevents_config_and_register(&nios2_ce.ced, freq, 1, ULONG_MAX);
+        return 0;
 }
-static __init void nios2_clocksource_init(struct device_node *timer)
+static __init int nios2_clocksource_init(struct device_node *timer)
 {
        unsigned int ctrl;
        void __iomem *iobase;
        u32 freq;
+        int ret;
-        nios2_timer_get_base_and_freq(timer, &iobase, &freq);
+        ret = nios2_timer_get_base_and_freq(timer, &iobase, &freq);
+        if (ret)
+                return ret;
        nios2_cs.timer.base = iobase;
        nios2_cs.timer.freq = freq;
-        clocksource_register_hz(&nios2_cs.cs, freq);
+        ret = clocksource_register_hz(&nios2_cs.cs, freq);
+        if (ret)
+                return ret;
        timer_writew(&nios2_cs.timer, USHRT_MAX, ALTERA_TIMER_PERIODL_REG);
        timer_writew(&nios2_cs.timer, USHRT_MAX, ALTERA_TIMER_PERIODH_REG);
@@ -282,6 +302,8 @@ static __init void nios2_clocksource_init(struct device_node *timer)
        /* Calibrate the delay loop directly */
        lpj_fine = freq / HZ;
+        return 0;
 }
 /*
@@ -289,22 +311,25 @@ static __init void nios2_clocksource_init(struct device_node *timer)
 * more instances, the second one gets used as clocksource and all
 * others are unused.
 */
-static void __init nios2_time_init(struct device_node *timer)
+static int __init nios2_time_init(struct device_node *timer)
 {
        static int num_called;
+        int ret;
        switch (num_called) {
        case 0:
-                nios2_clockevent_init(timer);
+                ret = nios2_clockevent_init(timer);
                break;
        case 1:
-                nios2_clocksource_init(timer);
+                ret = nios2_clocksource_init(timer);
                break;
        default:
                break;
        }
        num_called++;
+        return ret;
 }
 void read_persistent_clock(struct timespec *ts)
diff --git a/arch/x86/kernel/apic/x2apic_uv_x.c b/arch/x86/kernel/apic/x2apic_uv_x.c
index 5a58c917179c..64dd38fbf218 100644
--- a/arch/x86/kernel/apic/x2apic_uv_x.c
+++ b/arch/x86/kernel/apic/x2apic_uv_x.c
@@ -918,7 +918,7 @@ static void uv_heartbeat(unsigned long ignored)
        uv_set_scir_bits(bits);
        /* enable next timer period */
-        mod_timer_pinned(timer, jiffies + SCIR_CPU_HB_INTERVAL);
+        mod_timer(timer, jiffies + SCIR_CPU_HB_INTERVAL);
 }
 static void uv_heartbeat_enable(int cpu)
@@ -927,7 +927,7 @@ static void uv_heartbeat_enable(int cpu)
                struct timer_list *timer = &uv_cpu_scir_info(cpu)->timer;
                uv_set_cpu_scir_bits(cpu, SCIR_CPU_HEARTBEAT|SCIR_CPU_ACTIVITY);
-                setup_timer(timer, uv_heartbeat, cpu);
+                setup_pinned_timer(timer, uv_heartbeat, cpu);
                timer->expires = jiffies + SCIR_CPU_HB_INTERVAL;
                add_timer_on(timer, cpu);
                uv_cpu_scir_info(cpu)->enabled = 1;
diff --git a/arch/x86/kernel/cpu/mcheck/mce.c b/arch/x86/kernel/cpu/mcheck/mce.c
index 58af6300992d..79d8ec849468 100644
--- a/arch/x86/kernel/cpu/mcheck/mce.c
+++ b/arch/x86/kernel/cpu/mcheck/mce.c
@@ -1309,7 +1309,7 @@ static void __restart_timer(struct timer_list *t, unsigned long interval)
        if (timer_pending(t)) {
                if (time_before(when, t->expires))
-                        mod_timer_pinned(t, when);
+                        mod_timer(t, when);
        } else {
                t->expires = round_jiffies(when);
                add_timer_on(t, smp_processor_id());
@@ -1735,7 +1735,7 @@ static void __mcheck_cpu_init_timer(void)
        struct timer_list *t = this_cpu_ptr(&mce_timer);
        unsigned int cpu = smp_processor_id();
-        setup_timer(t, mce_timer_fn, cpu);
+        setup_pinned_timer(t, mce_timer_fn, cpu);
        mce_start_timer(cpu, t);
 }
diff --git a/block/genhd.c b/block/genhd.c
index 9f42526b4d62..f06d7f3b075b 100644
--- a/block/genhd.c
+++ b/block/genhd.c
@@ -1523,12 +1523,7 @@ static void __disk_unblock_events(struct gendisk *disk, bool check_now)
        if (--ev->block)
                goto out_unlock;
-        /*
-         * Not exactly a latency critical operation, set poll timer
-         * slack to 25% and kick event check.
-         */
        intv = disk_events_poll_jiffies(disk);
-        set_timer_slack(&ev->dwork.timer, intv / 4);
        if (check_now)
                queue_delayed_work(system_freezable_power_efficient_wq,
                                &ev->dwork, 0);
diff --git a/drivers/clocksource/Kconfig b/drivers/clocksource/Kconfig
index 47352d25c15e..567788664723 100644
--- a/drivers/clocksource/Kconfig
+++ b/drivers/clocksource/Kconfig
@@ -27,6 +27,20 @@ config CLKBLD_I8253
 config CLKSRC_MMIO
        bool
+config BCM2835_TIMER
+        bool "BCM2835 timer driver" if COMPILE_TEST
+        depends on GENERIC_CLOCKEVENTS
+        select CLKSRC_MMIO
+        help
+          Enables the support for the BCM2835 timer driver.
+config BCM_KONA_TIMER
+        bool "BCM mobile timer driver" if COMPILE_TEST
+        depends on GENERIC_CLOCKEVENTS
+        select CLKSRC_MMIO
+        help
+          Enables the support for the BCM Kona mobile timer driver.
 config DIGICOLOR_TIMER
        bool "Digicolor timer driver" if COMPILE_TEST
        depends on GENERIC_CLOCKEVENTS
@@ -141,6 +155,72 @@ config CLKSRC_DBX500_PRCMU
        help
          Use the always on PRCMU Timer as clocksource
+config CLPS711X_TIMER
+        bool "Cirrus logic timer driver" if COMPILE_TEST
+        depends on GENERIC_CLOCKEVENTS
+        select CLKSRC_MMIO
+        help
+          Enables support for the Cirrus Logic PS711 timer.
+config ATLAS7_TIMER
+        bool "Atlas7 timer driver" if COMPILE_TEST
+        depends on GENERIC_CLOCKEVENTS
+        select CLKSRC_MMIO
+        help
+          Enables support for the Atlas7 timer.
+config MOXART_TIMER
+        bool "Moxart timer driver" if COMPILE_TEST
+        depends on GENERIC_CLOCKEVENTS
+        select CLKSRC_MMIO
+        help
+          Enables support for the Moxart timer.
+config MXS_TIMER
+        bool "Mxs timer driver" if COMPILE_TEST
+        depends on GENERIC_CLOCKEVENTS
+        select CLKSRC_MMIO
+        select STMP_DEVICE
+        help
+          Enables support for the Mxs timer.
+config PRIMA2_TIMER
+        bool "Prima2 timer driver" if COMPILE_TEST
+        depends on GENERIC_CLOCKEVENTS
+        select CLKSRC_MMIO
+        help
+          Enables support for the Prima2 timer.
+config U300_TIMER
+        bool "U300 timer driver" if COMPILE_TEST
+        depends on GENERIC_CLOCKEVENTS
+        depends on ARM
+        select CLKSRC_MMIO
+        help
+          Enables support for the U300 timer.
+config NSPIRE_TIMER
+        bool "NSpire timer driver" if COMPILE_TEST
+        depends on GENERIC_CLOCKEVENTS
+        select CLKSRC_MMIO
+        help
+          Enables support for the Nspire timer.
+config KEYSTONE_TIMER
+        bool "Keystone timer driver" if COMPILE_TEST
+        depends on GENERIC_CLOCKEVENTS
+        depends on ARM || ARM64
+        select CLKSRC_MMIO
+        help
+          Enables support for the Keystone timer.
+config INTEGRATOR_AP_TIMER
+        bool "Integrator-ap timer driver" if COMPILE_TEST
+        depends on GENERIC_CLOCKEVENTS
+        select CLKSRC_MMIO
+        help
+          Enables support for the Integrator-ap timer.
 config CLKSRC_DBX500_PRCMU_SCHED_CLOCK
        bool "Clocksource PRCMU Timer sched_clock"
        depends on (CLKSRC_DBX500_PRCMU && !CLKSRC_NOMADIK_MTU_SCHED_CLOCK)
@@ -208,14 +288,16 @@ config ARM_ARCH_TIMER
        select CLKSRC_ACPI if ACPI
 config ARM_ARCH_TIMER_EVTSTREAM
-        bool "Support for ARM architected timer event stream generation"
+        bool "Enable ARM architected timer event stream generation by default"
        default y if ARM_ARCH_TIMER
        depends on ARM_ARCH_TIMER
        help
-          This option enables support for event stream generation based on
+          This option enables support by default for event stream generation
-          the ARM architected timer. It is used for waking up CPUs executing
+          based on the ARM architected timer. It is used for waking up CPUs
-          the wfe instruction at a frequency represented as a power-of-2
+          executing the wfe instruction at a frequency represented as a
-          divisor of the clock rate.
+          power-of-2 divisor of the clock rate. The behaviour can also be
+          overridden on the command line using the
+          clocksource.arm_arch_timer.evtstream parameter.
          The main use of the event stream is wfe-based timeouts of userspace
          locking implementations. It might also be useful for imposing timeout
          on wfe to safeguard against any programming errors in case an expected
@@ -224,8 +306,9 @@ config ARM_ARCH_TIMER_EVTSTREAM
          hardware anomalies of missing events.
 config ARM_GLOBAL_TIMER
-        bool
+        bool "Support for the ARM global timer" if COMPILE_TEST
        select CLKSRC_OF if OF
+        depends on ARM
        help
          This options enables support for the ARM global timer unit
@@ -243,7 +326,7 @@ config CLKSRC_ARM_GLOBAL_TIMER_SCHED_CLOCK
         Use ARM global timer clock source as sched_clock
 config ARMV7M_SYSTICK
-        bool
+        bool "Support for the ARMv7M system time" if COMPILE_TEST
        select CLKSRC_OF if OF
        select CLKSRC_MMIO
        help
@@ -254,9 +337,12 @@ config ATMEL_PIT
        def_bool SOC_AT91SAM9 || SOC_SAMA5
 config ATMEL_ST
-        bool
+        bool "Atmel ST timer support" if COMPILE_TEST
+        depends on GENERIC_CLOCKEVENTS
        select CLKSRC_OF
        select MFD_SYSCON
+        help
+          Support for the Atmel ST timer.
 config CLKSRC_METAG_GENERIC
        def_bool y if METAG
@@ -270,7 +356,7 @@ config CLKSRC_EXYNOS_MCT
          Support for Multi Core Timer controller on Exynos SoCs.
 config CLKSRC_SAMSUNG_PWM
-        bool "PWM timer drvier for Samsung S3C, S5P" if COMPILE_TEST
+        bool "PWM timer driver for Samsung S3C, S5P" if COMPILE_TEST
        depends on GENERIC_CLOCKEVENTS
        depends on HAS_IOMEM
        help
@@ -293,6 +379,14 @@ config VF_PIT_TIMER
        help
          Support for Period Interrupt Timer on Freescale Vybrid Family SoCs.
+config OXNAS_RPS_TIMER
+        bool "Oxford Semiconductor OXNAS RPS Timers driver" if COMPILE_TEST
+        depends on GENERIC_CLOCKEVENTS
+        select CLKSRC_OF
+        select CLKSRC_MMIO
+        help
+          This enables support for the Oxford Semiconductor OXNAS RPS timers.
 config SYS_SUPPORTS_SH_CMT
        bool
@@ -361,8 +455,8 @@ config CLKSRC_QCOM
          Qualcomm SoCs.
 config CLKSRC_VERSATILE
-        bool "ARM Versatile (Express) reference platforms clock source"
+        bool "ARM Versatile (Express) reference platforms clock source" if COMPILE_TEST
-        depends on PLAT_VERSATILE && GENERIC_SCHED_CLOCK && !ARCH_USES_GETTIMEOFFSET
+        depends on GENERIC_SCHED_CLOCK && !ARCH_USES_GETTIMEOFFSET
        select CLKSRC_OF
        default y if MFD_VEXPRESS_SYSREG
        help
diff --git a/drivers/clocksource/Makefile b/drivers/clocksource/Makefile
index 473974f9590a..fd9d6df0bbc0 100644
--- a/drivers/clocksource/Makefile
+++ b/drivers/clocksource/Makefile
@@ -19,21 +19,21 @@ obj-$(CONFIG_CLKSRC_NOMADIK_MTU)	+= nomadik-mtu.o
 obj-$(CONFIG_CLKSRC_DBX500_PRCMU)       += clksrc-dbx500-prcmu.o
 obj-$(CONFIG_ARMADA_370_XP_TIMER)       += time-armada-370-xp.o
 obj-$(CONFIG_ORION_TIMER)       += time-orion.o
-obj-$(CONFIG_ARCH_BCM2835)      += bcm2835_timer.o
+obj-$(CONFIG_BCM2835_TIMER)     += bcm2835_timer.o
-obj-$(CONFIG_ARCH_CLPS711X)     += clps711x-timer.o
+obj-$(CONFIG_CLPS711X_TIMER)    += clps711x-timer.o
-obj-$(CONFIG_ARCH_ATLAS7)       += timer-atlas7.o
+obj-$(CONFIG_ATLAS7_TIMER)      += timer-atlas7.o
-obj-$(CONFIG_ARCH_MOXART)       += moxart_timer.o
+obj-$(CONFIG_MOXART_TIMER)      += moxart_timer.o
-obj-$(CONFIG_ARCH_MXS)          += mxs_timer.o
+obj-$(CONFIG_MXS_TIMER)         += mxs_timer.o
 obj-$(CONFIG_CLKSRC_PXA)        += pxa_timer.o
-obj-$(CONFIG_ARCH_PRIMA2)       += timer-prima2.o
+obj-$(CONFIG_PRIMA2_TIMER)      += timer-prima2.o
-obj-$(CONFIG_ARCH_U300)         += timer-u300.o
+obj-$(CONFIG_U300_TIMER)        += timer-u300.o
 obj-$(CONFIG_SUN4I_TIMER)       += sun4i_timer.o
 obj-$(CONFIG_SUN5I_HSTIMER)     += timer-sun5i.o
 obj-$(CONFIG_MESON6_TIMER)      += meson6_timer.o
 obj-$(CONFIG_TEGRA_TIMER)       += tegra20_timer.o
 obj-$(CONFIG_VT8500_TIMER)      += vt8500_timer.o
-obj-$(CONFIG_ARCH_NSPIRE)       += zevio-timer.o
+obj-$(CONFIG_NSPIRE_TIMER)      += zevio-timer.o
-obj-$(CONFIG_ARCH_BCM_MOBILE)   += bcm_kona_timer.o
+obj-$(CONFIG_BCM_KONA_TIMER)    += bcm_kona_timer.o
 obj-$(CONFIG_CADENCE_TTC_TIMER) += cadence_ttc_timer.o
 obj-$(CONFIG_CLKSRC_EFM32)      += time-efm32.o
 obj-$(CONFIG_CLKSRC_STM32)      += timer-stm32.o
@@ -48,6 +48,7 @@ obj-$(CONFIG_MTK_TIMER)		+= mtk_timer.o
 obj-$(CONFIG_CLKSRC_PISTACHIO)  += time-pistachio.o
 obj-$(CONFIG_CLKSRC_TI_32K)     += timer-ti-32k.o
 obj-$(CONFIG_CLKSRC_NPS)        += timer-nps.o
+obj-$(CONFIG_OXNAS_RPS_TIMER)   += timer-oxnas-rps.o
 obj-$(CONFIG_ARM_ARCH_TIMER)            += arm_arch_timer.o
 obj-$(CONFIG_ARM_GLOBAL_TIMER)          += arm_global_timer.o
@@ -55,8 +56,8 @@ obj-$(CONFIG_ARMV7M_SYSTICK)		+= armv7m_systick.o
 obj-$(CONFIG_ARM_TIMER_SP804)           += timer-sp804.o
 obj-$(CONFIG_CLKSRC_METAG_GENERIC)      += metag_generic.o
 obj-$(CONFIG_ARCH_HAS_TICK_BROADCAST)   += dummy_timer.o
-obj-$(CONFIG_ARCH_KEYSTONE)             += timer-keystone.o
+obj-$(CONFIG_KEYSTONE_TIMER)            += timer-keystone.o
-obj-$(CONFIG_ARCH_INTEGRATOR_AP)        += timer-integrator-ap.o
+obj-$(CONFIG_INTEGRATOR_AP_TIMER)       += timer-integrator-ap.o
 obj-$(CONFIG_CLKSRC_VERSATILE)          += versatile.o
 obj-$(CONFIG_CLKSRC_MIPS_GIC)           += mips-gic-timer.o
 obj-$(CONFIG_CLKSRC_TANGO_XTAL)         += tango_xtal.o
diff --git a/drivers/clocksource/arm_arch_timer.c b/drivers/clocksource/arm_arch_timer.c
index 4814446a0024..5effd3027319 100644
--- a/drivers/clocksource/arm_arch_timer.c
+++ b/drivers/clocksource/arm_arch_timer.c
@@ -79,6 +79,14 @@ static enum ppi_nr arch_timer_uses_ppi = VIRT_PPI;
 static bool arch_timer_c3stop;
 static bool arch_timer_mem_use_virtual;
+static bool evtstrm_enable = IS_ENABLED(CONFIG_ARM_ARCH_TIMER_EVTSTREAM);
+static int __init early_evtstrm_cfg(char *buf)
+{
+        return strtobool(buf, &evtstrm_enable);
+}
+early_param("clocksource.arm_arch_timer.evtstrm", early_evtstrm_cfg);
 /*
 * Architected system timer support.
 */
@@ -372,7 +380,7 @@ static int arch_timer_setup(struct clock_event_device *clk)
                enable_percpu_irq(arch_timer_ppi[PHYS_NONSECURE_PPI], 0);
        arch_counter_set_user_access();
-        if (IS_ENABLED(CONFIG_ARM_ARCH_TIMER_EVTSTREAM))
+        if (evtstrm_enable)
                arch_timer_configure_evtstream();
        return 0;
@@ -693,25 +701,26 @@ arch_timer_needs_probing(int type, const struct of_device_id *matches)
        return needs_probing;
 }
-static void __init arch_timer_common_init(void)
+static int __init arch_timer_common_init(void)
 {
        unsigned mask = ARCH_CP15_TIMER | ARCH_MEM_TIMER;
        /* Wait until both nodes are probed if we have two timers */
        if ((arch_timers_present & mask) != mask) {
                if (arch_timer_needs_probing(ARCH_MEM_TIMER, arch_timer_mem_of_match))
-                        return;
+                        return 0;
                if (arch_timer_needs_probing(ARCH_CP15_TIMER, arch_timer_of_match))
-                        return;
+                        return 0;
        }
        arch_timer_banner(arch_timers_present);
        arch_counter_register(arch_timers_present);
-        arch_timer_arch_init();
+        return arch_timer_arch_init();
 }
-static void __init arch_timer_init(void)
+static int __init arch_timer_init(void)
 {
+        int ret;
        /*
         * If HYP mode is available, we know that the physical timer
         * has been configured to be accessible from PL1. Use it, so
@@ -739,23 +748,30 @@ static void __init arch_timer_init(void)
                if (!has_ppi) {
                        pr_warn("arch_timer: No interrupt available, giving up\n");
-                        return;
+                        return -EINVAL;
                }
        }
-        arch_timer_register();
+        ret = arch_timer_register();
-        arch_timer_common_init();
+        if (ret)
+                return ret;
+        ret = arch_timer_common_init();
+        if (ret)
+                return ret;
        arch_timer_kvm_info.virtual_irq = arch_timer_ppi[VIRT_PPI];
+        
+        return 0;
 }
-static void __init arch_timer_of_init(struct device_node *np)
+static int __init arch_timer_of_init(struct device_node *np)
 {
        int i;
        if (arch_timers_present & ARCH_CP15_TIMER) {
                pr_warn("arch_timer: multiple nodes in dt, skipping\n");
-                return;
+                return 0;
        }
        arch_timers_present |= ARCH_CP15_TIMER;
@@ -774,23 +790,23 @@ static void __init arch_timer_of_init(struct device_node *np)
            of_property_read_bool(np, "arm,cpu-registers-not-fw-configured"))
                arch_timer_uses_ppi = PHYS_SECURE_PPI;
-        arch_timer_init();
+        return arch_timer_init();
 }
 CLOCKSOURCE_OF_DECLARE(armv7_arch_timer, "arm,armv7-timer", arch_timer_of_init);
 CLOCKSOURCE_OF_DECLARE(armv8_arch_timer, "arm,armv8-timer", arch_timer_of_init);
-static void __init arch_timer_mem_init(struct device_node *np)
+static int __init arch_timer_mem_init(struct device_node *np)
 {
        struct device_node *frame, *best_frame = NULL;
        void __iomem *cntctlbase, *base;
-        unsigned int irq;
+        unsigned int irq, ret = -EINVAL;
        u32 cnttidr;
        arch_timers_present |= ARCH_MEM_TIMER;
        cntctlbase = of_iomap(np, 0);
        if (!cntctlbase) {
                pr_err("arch_timer: Can't find CNTCTLBase\n");
-                return;
+                return -ENXIO;
        }
        cnttidr = readl_relaxed(cntctlbase + CNTTIDR);
@@ -830,6 +846,7 @@ static void __init arch_timer_mem_init(struct device_node *np)
                best_frame = of_node_get(frame);
        }
+        ret= -ENXIO;
        base = arch_counter_base = of_iomap(best_frame, 0);
        if (!base) {
                pr_err("arch_timer: Can't map frame's registers\n");
@@ -841,6 +858,7 @@ static void __init arch_timer_mem_init(struct device_node *np)
        else
                irq = irq_of_parse_and_map(best_frame, 0);
+        ret = -EINVAL;
        if (!irq) {
                pr_err("arch_timer: Frame missing %s irq",
                       arch_timer_mem_use_virtual ? "virt" : "phys");
@@ -848,11 +866,15 @@ static void __init arch_timer_mem_init(struct device_node *np)
        }
        arch_timer_detect_rate(base, np);
-        arch_timer_mem_register(base, irq);
+        ret = arch_timer_mem_register(base, irq);
-        arch_timer_common_init();
+        if (ret)
+                goto out;
+        return arch_timer_common_init();
 out:
        iounmap(cntctlbase);
        of_node_put(best_frame);
+        return ret;
 }
 CLOCKSOURCE_OF_DECLARE(armv7_arch_timer_mem, "arm,armv7-timer-mem",
                       arch_timer_mem_init);
diff --git a/drivers/clocksource/arm_global_timer.c b/drivers/clocksource/arm_global_timer.c
index 9df0d1699d22..2a9ceb6e93f9 100644
--- a/drivers/clocksource/arm_global_timer.c
+++ b/drivers/clocksource/arm_global_timer.c
@@ -238,7 +238,7 @@ static void __init gt_delay_timer_init(void)
        register_current_timer_delay(&gt_delay_timer);
 }
-static void __init gt_clocksource_init(void)
+static int __init gt_clocksource_init(void)
 {
        writel(0, gt_base + GT_CONTROL);
        writel(0, gt_base + GT_COUNTER0);
@@ -249,7 +249,7 @@ static void __init gt_clocksource_init(void)
 #ifdef CONFIG_CLKSRC_ARM_GLOBAL_TIMER_SCHED_CLOCK
        sched_clock_register(gt_sched_clock_read, 64, gt_clk_rate);
 #endif
-        clocksource_register_hz(&gt_clocksource, gt_clk_rate);
+        return clocksource_register_hz(&gt_clocksource, gt_clk_rate);
 }
 static int gt_cpu_notify(struct notifier_block *self, unsigned long action,
@@ -270,7 +270,7 @@ static struct notifier_block gt_cpu_nb = {
        .notifier_call = gt_cpu_notify,
 };
-static void __init global_timer_of_register(struct device_node *np)
+static int __init global_timer_of_register(struct device_node *np)
 {
        struct clk *gt_clk;
        int err = 0;
@@ -283,19 +283,19 @@ static void __init global_timer_of_register(struct device_node *np)
        if (read_cpuid_part() == ARM_CPU_PART_CORTEX_A9
            && (read_cpuid_id() & 0xf0000f) < 0x200000) {
                pr_warn("global-timer: non support for this cpu version.\n");
-                return;
+                return -ENOSYS;
        }
        gt_ppi = irq_of_parse_and_map(np, 0);
        if (!gt_ppi) {
                pr_warn("global-timer: unable to parse irq\n");
-                return;
+                return -EINVAL;
        }
        gt_base = of_iomap(np, 0);
        if (!gt_base) {
                pr_warn("global-timer: invalid base address\n");
-                return;
+                return -ENXIO;
        }
        gt_clk = of_clk_get(np, 0);
@@ -332,11 +332,17 @@ static void __init global_timer_of_register(struct device_node *np)
        }
        /* Immediately configure the timer on the boot CPU */
-        gt_clocksource_init();
+        err = gt_clocksource_init();
-        gt_clockevents_init(this_cpu_ptr(gt_evt));
+        if (err)
+                goto out_irq;
+        
+        err = gt_clockevents_init(this_cpu_ptr(gt_evt));
+        if (err)
+                goto out_irq;
        gt_delay_timer_init();
-        return;
+        return 0;
 out_irq:
        free_percpu_irq(gt_ppi, gt_evt);
@@ -347,6 +353,8 @@ out_clk:
 out_unmap:
        iounmap(gt_base);
        WARN(err, "ARM Global timer register failed (%d)\n", err);
+        return err;
 }
 /* Only tested on r2p2 and r3p0  */
diff --git a/drivers/clocksource/armv7m_systick.c b/drivers/clocksource/armv7m_systick.c
index addfd2c64f54..a315491b7047 100644
--- a/drivers/clocksource/armv7m_systick.c
+++ b/drivers/clocksource/armv7m_systick.c
@@ -7,6 +7,7 @@
 #include <linux/kernel.h>
 #include <linux/clocksource.h>
 #include <linux/clockchips.h>
+#include <linux/io.h>
 #include <linux/of.h>
 #include <linux/of_address.h>
 #include <linux/clk.h>
@@ -21,7 +22,7 @@
 #define SYSTICK_LOAD_RELOAD_MASK 0x00FFFFFF
-static void __init system_timer_of_register(struct device_node *np)
+static int __init system_timer_of_register(struct device_node *np)
 {
        struct clk *clk = NULL;
        void __iomem *base;
@@ -31,22 +32,26 @@ static void __init system_timer_of_register(struct device_node *np)
        base = of_iomap(np, 0);
        if (!base) {
                pr_warn("system-timer: invalid base address\n");
-                return;
+                return -ENXIO;
        }
        ret = of_property_read_u32(np, "clock-frequency", &rate);
        if (ret) {
                clk = of_clk_get(np, 0);
-                if (IS_ERR(clk))
+                if (IS_ERR(clk)) {
+                        ret = PTR_ERR(clk);
                        goto out_unmap;
+                }
                ret = clk_prepare_enable(clk);
                if (ret)
                        goto out_clk_put;
                rate = clk_get_rate(clk);
-                if (!rate)
+                if (!rate) {
+                        ret = -EINVAL;
                        goto out_clk_disable;
+                }
        }
        writel_relaxed(SYSTICK_LOAD_RELOAD_MASK, base + SYST_RVR);
@@ -64,7 +69,7 @@ static void __init system_timer_of_register(struct device_node *np)
        pr_info("ARM System timer initialized as clocksource\n");
-        return;
+        return 0;
 out_clk_disable:
        clk_disable_unprepare(clk);
@@ -73,6 +78,8 @@ out_clk_put:
 out_unmap:
        iounmap(base);
        pr_warn("ARM System timer register failed (%d)\n", ret);
+        return ret;
 }
 CLOCKSOURCE_OF_DECLARE(arm_systick, "arm,armv7m-systick",
diff --git a/drivers/clocksource/asm9260_timer.c b/drivers/clocksource/asm9260_timer.c
index 217438d39eb3..1ba871b7fe11 100644
--- a/drivers/clocksource/asm9260_timer.c
+++ b/drivers/clocksource/asm9260_timer.c
@@ -184,7 +184,7 @@ static irqreturn_t asm9260_timer_interrupt(int irq, void *dev_id)
 * Timer initialization
 * ---------------------------------------------------------------------------
 */
-static void __init asm9260_timer_init(struct device_node *np)
+static int __init asm9260_timer_init(struct device_node *np)
 {
        int irq;
        struct clk *clk;
@@ -192,20 +192,26 @@ static void __init asm9260_timer_init(struct device_node *np)
        unsigned long rate;
        priv.base = of_io_request_and_map(np, 0, np->name);
-        if (IS_ERR(priv.base))
+        if (IS_ERR(priv.base)) {
-                panic("%s: unable to map resource", np->name);
+                pr_err("%s: unable to map resource", np->name);
+                return PTR_ERR(priv.base);
+        }
        clk = of_clk_get(np, 0);
        ret = clk_prepare_enable(clk);
-        if (ret)
+        if (ret) {
-                panic("Failed to enable clk!\n");
+                pr_err("Failed to enable clk!\n");
+                return ret;
+        }
        irq = irq_of_parse_and_map(np, 0);
        ret = request_irq(irq, asm9260_timer_interrupt, IRQF_TIMER,
                        DRIVER_NAME, &event_dev);
-        if (ret)
+        if (ret) {
-                panic("Failed to setup irq!\n");
+                pr_err("Failed to setup irq!\n");
+                return ret;
+        }
        /* set all timers for count-up */
        writel_relaxed(BM_DIR_DEFAULT, priv.base + HW_DIR);
@@ -229,6 +235,8 @@ static void __init asm9260_timer_init(struct device_node *np)
        priv.ticks_per_jiffy = DIV_ROUND_CLOSEST(rate, HZ);
        event_dev.cpumask = cpumask_of(0);
        clockevents_config_and_register(&event_dev, rate, 0x2c00, 0xfffffffe);
+        return 0;
 }
 CLOCKSOURCE_OF_DECLARE(asm9260_timer, "alphascale,asm9260-timer",
                asm9260_timer_init);
diff --git a/drivers/clocksource/bcm2835_timer.c b/drivers/clocksource/bcm2835_timer.c
index 6f2822928963..e71acf231c89 100644
--- a/drivers/clocksource/bcm2835_timer.c
+++ b/drivers/clocksource/bcm2835_timer.c
@@ -80,19 +80,24 @@ static irqreturn_t bcm2835_time_interrupt(int irq, void *dev_id)
        }
 }
-static void __init bcm2835_timer_init(struct device_node *node)
+static int __init bcm2835_timer_init(struct device_node *node)
 {
        void __iomem *base;
        u32 freq;
-        int irq;
+        int irq, ret;
        struct bcm2835_timer *timer;
        base = of_iomap(node, 0);
-        if (!base)
+        if (!base) {
-                panic("Can't remap registers");
+                pr_err("Can't remap registers");
+                return -ENXIO;
+        }
-        if (of_property_read_u32(node, "clock-frequency", &freq))
+        ret = of_property_read_u32(node, "clock-frequency", &freq);
-                panic("Can't read clock-frequency");
+        if (ret) {
+                pr_err("Can't read clock-frequency");
+                return ret;
+        }
        system_clock = base + REG_COUNTER_LO;
        sched_clock_register(bcm2835_sched_read, 32, freq);
@@ -101,12 +106,16 @@ static void __init bcm2835_timer_init(struct device_node *node)
                freq, 300, 32, clocksource_mmio_readl_up);
        irq = irq_of_parse_and_map(node, DEFAULT_TIMER);
-        if (irq <= 0)
+        if (irq <= 0) {
-                panic("Can't parse IRQ");
+                pr_err("Can't parse IRQ");
+                return -EINVAL;
+        }
        timer = kzalloc(sizeof(*timer), GFP_KERNEL);
-        if (!timer)
+        if (!timer) {
-                panic("Can't allocate timer struct\n");
+                pr_err("Can't allocate timer struct\n");
+                return -ENOMEM;
+        }
        timer->control = base + REG_CONTROL;
        timer->compare = base + REG_COMPARE(DEFAULT_TIMER);
@@ -121,12 +130,17 @@ static void __init bcm2835_timer_init(struct device_node *node)
        timer->act.dev_id = timer;
        timer->act.handler = bcm2835_time_interrupt;
-        if (setup_irq(irq, &timer->act))
+        ret = setup_irq(irq, &timer->act);
-                panic("Can't set up timer IRQ\n");
+        if (ret) {
+                pr_err("Can't set up timer IRQ\n");
+                return ret;
+        }
        clockevents_config_and_register(&timer->evt, freq, 0xf, 0xffffffff);
        pr_info("bcm2835: system timer (irq = %d)\n", irq);
+        return 0;
 }
 CLOCKSOURCE_OF_DECLARE(bcm2835, "brcm,bcm2835-system-timer",
                        bcm2835_timer_init);
diff --git a/drivers/clocksource/bcm_kona_timer.c b/drivers/clocksource/bcm_kona_timer.c
index e717e87df9bc..7e3fd375a627 100644
--- a/drivers/clocksource/bcm_kona_timer.c
+++ b/drivers/clocksource/bcm_kona_timer.c
@@ -20,7 +20,6 @@
 #include <linux/clk.h>
 #include <linux/io.h>
-#include <asm/mach/time.h>
 #include <linux/of.h>
 #include <linux/of_address.h>
@@ -163,16 +162,11 @@ static struct irqaction kona_timer_irq = {
        .handler = kona_timer_interrupt,
 };
-static void __init kona_timer_init(struct device_node *node)
+static int __init kona_timer_init(struct device_node *node)
 {
        u32 freq;
        struct clk *external_clk;
-        if (!of_device_is_available(node)) {
-                pr_info("Kona Timer v1 marked as disabled in device tree\n");
-                return;
-        }
        external_clk = of_clk_get_by_name(node, NULL);
        if (!IS_ERR(external_clk)) {
@@ -182,7 +176,7 @@ static void __init kona_timer_init(struct device_node *node)
                arch_timer_rate = freq;
        } else {
                pr_err("Kona Timer v1 unable to determine clock-frequency");
-                return;
+                return -EINVAL;
        }
        /* Setup IRQ numbers */
@@ -196,6 +190,8 @@ static void __init kona_timer_init(struct device_node *node)
        kona_timer_clockevents_init();
        setup_irq(timers.tmr_irq, &kona_timer_irq);
        kona_timer_set_next_event((arch_timer_rate / HZ), NULL);
+        return 0;
 }
 CLOCKSOURCE_OF_DECLARE(brcm_kona, "brcm,kona-timer", kona_timer_init);
diff --git a/drivers/clocksource/cadence_ttc_timer.c b/drivers/clocksource/cadence_ttc_timer.c
index 9be6018bd2b8..fbfbdec13b08 100644
--- a/drivers/clocksource/cadence_ttc_timer.c
+++ b/drivers/clocksource/cadence_ttc_timer.c
@@ -322,22 +322,22 @@ static int ttc_rate_change_clocksource_cb(struct notifier_block *nb,
        return NOTIFY_DONE;
 }
-static void __init ttc_setup_clocksource(struct clk *clk, void __iomem *base,
+static int __init ttc_setup_clocksource(struct clk *clk, void __iomem *base,
                                         u32 timer_width)
 {
        struct ttc_timer_clocksource *ttccs;
        int err;
        ttccs = kzalloc(sizeof(*ttccs), GFP_KERNEL);
-        if (WARN_ON(!ttccs))
+        if (!ttccs)
-                return;
+                return -ENOMEM;
        ttccs->ttc.clk = clk;
        err = clk_prepare_enable(ttccs->ttc.clk);
-        if (WARN_ON(err)) {
+        if (err) {
                kfree(ttccs);
-                return;
+                return err;
        }
        ttccs->ttc.freq = clk_get_rate(ttccs->ttc.clk);
@@ -345,8 +345,10 @@ static void __init ttc_setup_clocksource(struct clk *clk, void __iomem *base,
        ttccs->ttc.clk_rate_change_nb.notifier_call =
                ttc_rate_change_clocksource_cb;
        ttccs->ttc.clk_rate_change_nb.next = NULL;
-        if (clk_notifier_register(ttccs->ttc.clk,
-                                &ttccs->ttc.clk_rate_change_nb))
+        err = clk_notifier_register(ttccs->ttc.clk,
+                                    &ttccs->ttc.clk_rate_change_nb);
+        if (err)
                pr_warn("Unable to register clock notifier.\n");
        ttccs->ttc.base_addr = base;
@@ -368,14 +370,16 @@ static void __init ttc_setup_clocksource(struct clk *clk, void __iomem *base,
                     ttccs->ttc.base_addr + TTC_CNT_CNTRL_OFFSET);
        err = clocksource_register_hz(&ttccs->cs, ttccs->ttc.freq / PRESCALE);
-        if (WARN_ON(err)) {
+        if (err) {
                kfree(ttccs);
-                return;
+                return err;
        }
        ttc_sched_clock_val_reg = base + TTC_COUNT_VAL_OFFSET;
        sched_clock_register(ttc_sched_clock_read, timer_width,
                             ttccs->ttc.freq / PRESCALE);
+        return 0;
 }
 static int ttc_rate_change_clockevent_cb(struct notifier_block *nb,
@@ -401,30 +405,35 @@ static int ttc_rate_change_clockevent_cb(struct notifier_block *nb,
        }
 }
-static void __init ttc_setup_clockevent(struct clk *clk,
+static int __init ttc_setup_clockevent(struct clk *clk,
-                                                void __iomem *base, u32 irq)
+                                       void __iomem *base, u32 irq)
 {
        struct ttc_timer_clockevent *ttcce;
        int err;
        ttcce = kzalloc(sizeof(*ttcce), GFP_KERNEL);
-        if (WARN_ON(!ttcce))
+        if (!ttcce)
-                return;
+                return -ENOMEM;
        ttcce->ttc.clk = clk;
        err = clk_prepare_enable(ttcce->ttc.clk);
-        if (WARN_ON(err)) {
+        if (err) {
                kfree(ttcce);
-                return;
+                return err;
        }
        ttcce->ttc.clk_rate_change_nb.notifier_call =
                ttc_rate_change_clockevent_cb;
        ttcce->ttc.clk_rate_change_nb.next = NULL;
-        if (clk_notifier_register(ttcce->ttc.clk,
-                                &ttcce->ttc.clk_rate_change_nb))
+        err = clk_notifier_register(ttcce->ttc.clk,
+                                    &ttcce->ttc.clk_rate_change_nb);
+        if (err) {
                pr_warn("Unable to register clock notifier.\n");
+                return err;
+        }
        ttcce->ttc.freq = clk_get_rate(ttcce->ttc.clk);
        ttcce->ttc.base_addr = base;
@@ -451,13 +460,15 @@ static void __init ttc_setup_clockevent(struct clk *clk,
        err = request_irq(irq, ttc_clock_event_interrupt,
                          IRQF_TIMER, ttcce->ce.name, ttcce);
-        if (WARN_ON(err)) {
+        if (err) {
                kfree(ttcce);
-                return;
+                return err;
        }
        clockevents_config_and_register(&ttcce->ce,
                        ttcce->ttc.freq / PRESCALE, 1, 0xfffe);
+        return 0;
 }
 /**
@@ -466,17 +477,17 @@ static void __init ttc_setup_clockevent(struct clk *clk,
 * Initializes the timer hardware and register the clock source and clock event
 * timers with Linux kernal timer framework
 */
-static void __init ttc_timer_init(struct device_node *timer)
+static int __init ttc_timer_init(struct device_node *timer)
 {
        unsigned int irq;
        void __iomem *timer_baseaddr;
        struct clk *clk_cs, *clk_ce;
        static int initialized;
-        int clksel;
+        int clksel, ret;
        u32 timer_width = 16;
        if (initialized)
-                return;
+                return 0;
        initialized = 1;
@@ -488,13 +499,13 @@ static void __init ttc_timer_init(struct device_node *timer)
        timer_baseaddr = of_iomap(timer, 0);
        if (!timer_baseaddr) {
                pr_err("ERROR: invalid timer base address\n");
-                BUG();
+                return -ENXIO;
        }
        irq = irq_of_parse_and_map(timer, 1);
        if (irq <= 0) {
                pr_err("ERROR: invalid interrupt number\n");
-                BUG();
+                return -EINVAL;
        }
        of_property_read_u32(timer, "timer-width", &timer_width);
@@ -504,7 +515,7 @@ static void __init ttc_timer_init(struct device_node *timer)
        clk_cs = of_clk_get(timer, clksel);
        if (IS_ERR(clk_cs)) {
                pr_err("ERROR: timer input clock not found\n");
-                BUG();
+                return PTR_ERR(clk_cs);
        }
        clksel = readl_relaxed(timer_baseaddr + 4 + TTC_CLK_CNTRL_OFFSET);
@@ -512,13 +523,20 @@ static void __init ttc_timer_init(struct device_node *timer)
        clk_ce = of_clk_get(timer, clksel);
        if (IS_ERR(clk_ce)) {
                pr_err("ERROR: timer input clock not found\n");
-                BUG();
+                return PTR_ERR(clk_ce);
        }
-        ttc_setup_clocksource(clk_cs, timer_baseaddr, timer_width);
+        ret = ttc_setup_clocksource(clk_cs, timer_baseaddr, timer_width);
-        ttc_setup_clockevent(clk_ce, timer_baseaddr + 4, irq);
+        if (ret)
+                return ret;
+        ret = ttc_setup_clockevent(clk_ce, timer_baseaddr + 4, irq);
+        if (ret)
+                return ret;
        pr_info("%s #0 at %p, irq=%d\n", timer->name, timer_baseaddr, irq);
+        return 0;
 }
 CLOCKSOURCE_OF_DECLARE(ttc, "cdns,ttc", ttc_timer_init);
diff --git a/drivers/clocksource/clksrc-dbx500-prcmu.c b/drivers/clocksource/clksrc-dbx500-prcmu.c
index dfad6eb99662..77a365f573d7 100644
--- a/drivers/clocksource/clksrc-dbx500-prcmu.c
+++ b/drivers/clocksource/clksrc-dbx500-prcmu.c
@@ -64,7 +64,7 @@ static u64 notrace dbx500_prcmu_sched_clock_read(void)
 #endif
-static void __init clksrc_dbx500_prcmu_init(struct device_node *node)
+static int __init clksrc_dbx500_prcmu_init(struct device_node *node)
 {
        clksrc_dbx500_timer_base = of_iomap(node, 0);
@@ -84,7 +84,7 @@ static void __init clksrc_dbx500_prcmu_init(struct device_node *node)
 #ifdef CONFIG_CLKSRC_DBX500_PRCMU_SCHED_CLOCK
        sched_clock_register(dbx500_prcmu_sched_clock_read, 32, RATE_32K);
 #endif
-        clocksource_register_hz(&clocksource_dbx500_prcmu, RATE_32K);
+        return clocksource_register_hz(&clocksource_dbx500_prcmu, RATE_32K);
 }
 CLOCKSOURCE_OF_DECLARE(dbx500_prcmu, "stericsson,db8500-prcmu-timer-4",
                       clksrc_dbx500_prcmu_init);
diff --git a/drivers/clocksource/clksrc-probe.c b/drivers/clocksource/clksrc-probe.c
index 7cb6c923a836..bc62be97f0a8 100644
--- a/drivers/clocksource/clksrc-probe.c
+++ b/drivers/clocksource/clksrc-probe.c
@@ -28,15 +28,23 @@ void __init clocksource_probe(void)
 {
        struct device_node *np;
        const struct of_device_id *match;
-        of_init_fn_1 init_func;
+        of_init_fn_1_ret init_func_ret;
        unsigned clocksources = 0;
+        int ret;
        for_each_matching_node_and_match(np, __clksrc_of_table, &match) {
                if (!of_device_is_available(np))
                        continue;
-                init_func = match->data;
+                init_func_ret = match->data;
-                init_func(np);
+                ret = init_func_ret(np);
+                if (ret) {
+                        pr_err("Failed to initialize '%s': %d",
+                               of_node_full_name(np), ret);
+                        continue;
+                }
                clocksources++;
        }
diff --git a/drivers/clocksource/clksrc_st_lpc.c b/drivers/clocksource/clksrc_st_lpc.c
index 65ec4674416d..03cc49217bb4 100644
--- a/drivers/clocksource/clksrc_st_lpc.c
+++ b/drivers/clocksource/clksrc_st_lpc.c
@@ -92,7 +92,7 @@ static int __init st_clksrc_setup_clk(struct device_node *np)
        return 0;
 }
-static void __init st_clksrc_of_register(struct device_node *np)
+static int __init st_clksrc_of_register(struct device_node *np)
 {
        int ret;
        uint32_t mode;
@@ -100,32 +100,36 @@ static void __init st_clksrc_of_register(struct device_node *np)
        ret = of_property_read_u32(np, "st,lpc-mode", &mode);
        if (ret) {
                pr_err("clksrc-st-lpc: An LPC mode must be provided\n");
-                return;
+                return ret;
        }
        /* LPC can either run as a Clocksource or in RTC or WDT mode */
        if (mode != ST_LPC_MODE_CLKSRC)
-                return;
+                return 0;
        ddata.base = of_iomap(np, 0);
        if (!ddata.base) {
                pr_err("clksrc-st-lpc: Unable to map iomem\n");
-                return;
+                return -ENXIO;
        }
-        if (st_clksrc_setup_clk(np)) {
+        ret = st_clksrc_setup_clk(np);
+        if (ret) {
                iounmap(ddata.base);
-                return;
+                return ret;
        }
-        if (st_clksrc_init()) {
+        ret = st_clksrc_init();
+        if (ret) {
                clk_disable_unprepare(ddata.clk);
                clk_put(ddata.clk);
                iounmap(ddata.base);
-                return;
+                return ret;
        }
        pr_info("clksrc-st-lpc: clocksource initialised - running @ %luHz\n",
                clk_get_rate(ddata.clk));
+        return ret;
 }
 CLOCKSOURCE_OF_DECLARE(ddata, "st,stih407-lpc", st_clksrc_of_register);
diff --git a/drivers/clocksource/clps711x-timer.c b/drivers/clocksource/clps711x-timer.c
index cdd86e3525bb..84aed78261e4 100644
--- a/drivers/clocksource/clps711x-timer.c
+++ b/drivers/clocksource/clps711x-timer.c
@@ -104,7 +104,7 @@ void __init clps711x_clksrc_init(void __iomem *tc1_base, void __iomem *tc2_base,
 }
 #ifdef CONFIG_CLKSRC_OF
-static void __init clps711x_timer_init(struct device_node *np)
+static int __init clps711x_timer_init(struct device_node *np)
 {
        unsigned int irq = irq_of_parse_and_map(np, 0);
        struct clk *clock = of_clk_get(np, 0);
@@ -112,13 +112,11 @@ static void __init clps711x_timer_init(struct device_node *np)
        switch (of_alias_get_id(np, "timer")) {
        case CLPS711X_CLKSRC_CLOCKSOURCE:
-                BUG_ON(_clps711x_clksrc_init(clock, base));
+                return _clps711x_clksrc_init(clock, base);
-                break;
        case CLPS711X_CLKSRC_CLOCKEVENT:
-                BUG_ON(_clps711x_clkevt_init(clock, base, irq));
+                return _clps711x_clkevt_init(clock, base, irq);
-                break;
        default:
-                break;
+                return -EINVAL;
        }
 }
 CLOCKSOURCE_OF_DECLARE(clps711x, "cirrus,clps711x-timer", clps711x_timer_init);
diff --git a/drivers/clocksource/dw_apb_timer_of.c b/drivers/clocksource/dw_apb_timer_of.c
index 860843cef572..aee6c0d39a7c 100644
--- a/drivers/clocksource/dw_apb_timer_of.c
+++ b/drivers/clocksource/dw_apb_timer_of.c
@@ -143,7 +143,7 @@ static struct delay_timer dw_apb_delay_timer = {
 #endif
 static int num_called;
-static void __init dw_apb_timer_init(struct device_node *timer)
+static int __init dw_apb_timer_init(struct device_node *timer)
 {
        switch (num_called) {
        case 0:
@@ -164,6 +164,8 @@ static void __init dw_apb_timer_init(struct device_node *timer)
        }
        num_called++;
+        return 0;
 }
 CLOCKSOURCE_OF_DECLARE(pc3x2_timer, "picochip,pc3x2-timer", dw_apb_timer_init);
 CLOCKSOURCE_OF_DECLARE(apb_timer_osc, "snps,dw-apb-timer-osc", dw_apb_timer_init);
diff --git a/drivers/clocksource/exynos_mct.c b/drivers/clocksource/exynos_mct.c
index be09bc0b5e26..0d18dd4b3bd2 100644
--- a/drivers/clocksource/exynos_mct.c
+++ b/drivers/clocksource/exynos_mct.c
@@ -232,7 +232,7 @@ static cycles_t exynos4_read_current_timer(void)
        return exynos4_read_count_32();
 }
-static void __init exynos4_clocksource_init(void)
+static int __init exynos4_clocksource_init(void)
 {
        exynos4_mct_frc_start();
@@ -244,6 +244,8 @@ static void __init exynos4_clocksource_init(void)
                panic("%s: can't register clocksource\n", mct_frc.name);
        sched_clock_register(exynos4_read_sched_clock, 32, clk_rate);
+        return 0;
 }
 static void exynos4_mct_comp0_stop(void)
@@ -335,12 +337,14 @@ static struct irqaction mct_comp_event_irq = {
        .dev_id         = &mct_comp_device,
 };
-static void exynos4_clockevent_init(void)
+static int exynos4_clockevent_init(void)
 {
        mct_comp_device.cpumask = cpumask_of(0);
        clockevents_config_and_register(&mct_comp_device, clk_rate,
                                        0xf, 0xffffffff);
        setup_irq(mct_irqs[MCT_G0_IRQ], &mct_comp_event_irq);
+        return 0;
 }
 static DEFINE_PER_CPU(struct mct_clock_event_device, percpu_mct_tick);
@@ -516,7 +520,7 @@ static struct notifier_block exynos4_mct_cpu_nb = {
        .notifier_call = exynos4_mct_cpu_notify,
 };
-static void __init exynos4_timer_resources(struct device_node *np, void __iomem *base)
+static int __init exynos4_timer_resources(struct device_node *np, void __iomem *base)
 {
        int err, cpu;
        struct mct_clock_event_device *mevt = this_cpu_ptr(&percpu_mct_tick);
@@ -572,15 +576,17 @@ static void __init exynos4_timer_resources(struct device_node *np, void __iomem
        /* Immediately configure the timer on the boot CPU */
        exynos4_local_timer_setup(mevt);
-        return;
+        return 0;
 out_irq:
        free_percpu_irq(mct_irqs[MCT_L0_IRQ], &percpu_mct_tick);
+        return err;
 }
-static void __init mct_init_dt(struct device_node *np, unsigned int int_type)
+static int __init mct_init_dt(struct device_node *np, unsigned int int_type)
 {
        u32 nr_irqs, i;
+        int ret;
        mct_int_type = int_type;
@@ -600,18 +606,24 @@ static void __init mct_init_dt(struct device_node *np, unsigned int int_type)
        for (i = MCT_L0_IRQ; i < nr_irqs; i++)
                mct_irqs[i] = irq_of_parse_and_map(np, i);
-        exynos4_timer_resources(np, of_iomap(np, 0));
+        ret = exynos4_timer_resources(np, of_iomap(np, 0));
-        exynos4_clocksource_init();
+        if (ret)
-        exynos4_clockevent_init();
+                return ret;
+        ret = exynos4_clocksource_init();
+        if (ret)
+                return ret;
+        return exynos4_clockevent_init();
 }
-static void __init mct_init_spi(struct device_node *np)
+static int __init mct_init_spi(struct device_node *np)
 {
        return mct_init_dt(np, MCT_INT_SPI);
 }
-static void __init mct_init_ppi(struct device_node *np)
+static int __init mct_init_ppi(struct device_node *np)
 {
        return mct_init_dt(np, MCT_INT_PPI);
 }
diff --git a/drivers/clocksource/fsl_ftm_timer.c b/drivers/clocksource/fsl_ftm_timer.c
index 517e1c7624d4..738515b89073 100644
--- a/drivers/clocksource/fsl_ftm_timer.c
+++ b/drivers/clocksource/fsl_ftm_timer.c
@@ -316,15 +316,16 @@ static int __init ftm_calc_closest_round_cyc(unsigned long freq)
        return 0;
 }
-static void __init ftm_timer_init(struct device_node *np)
+static int __init ftm_timer_init(struct device_node *np)
 {
        unsigned long freq;
-        int irq;
+        int ret, irq;
        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
        if (!priv)
-                return;
+                return -ENOMEM;
+        ret = -ENXIO;
        priv->clkevt_base = of_iomap(np, 0);
        if (!priv->clkevt_base) {
                pr_err("ftm: unable to map event timer registers\n");
@@ -337,6 +338,7 @@ static void __init ftm_timer_init(struct device_node *np)
                goto err;
        }
+        ret = -EINVAL;
        irq = irq_of_parse_and_map(np, 0);
        if (irq <= 0) {
                pr_err("ftm: unable to get IRQ from DT, %d\n", irq);
@@ -349,18 +351,22 @@ static void __init ftm_timer_init(struct device_node *np)
        if (!freq)
                goto err;
-        if (ftm_calc_closest_round_cyc(freq))
+        ret = ftm_calc_closest_round_cyc(freq);
+        if (ret)
                goto err;
-        if (ftm_clocksource_init(freq))
+        ret = ftm_clocksource_init(freq);
+        if (ret)
                goto err;
-        if (ftm_clockevent_init(freq, irq))
+        ret = ftm_clockevent_init(freq, irq);
+        if (ret)
                goto err;
-        return;
+        return 0;
 err:
        kfree(priv);
+        return ret;
 }
 CLOCKSOURCE_OF_DECLARE(flextimer, "fsl,ftm-timer", ftm_timer_init);
diff --git a/drivers/clocksource/h8300_timer16.c b/drivers/clocksource/h8300_timer16.c
index 75c44079b345..07d9d5be9054 100644
--- a/drivers/clocksource/h8300_timer16.c
+++ b/drivers/clocksource/h8300_timer16.c
@@ -126,7 +126,7 @@ static struct timer16_priv timer16_priv = {
 #define REG_CH   0
 #define REG_COMM 1
-static void __init h8300_16timer_init(struct device_node *node)
+static int __init h8300_16timer_init(struct device_node *node)
 {
        void __iomem *base[2];
        int ret, irq;
@@ -136,9 +136,10 @@ static void __init h8300_16timer_init(struct device_node *node)
        clk = of_clk_get(node, 0);
        if (IS_ERR(clk)) {
                pr_err("failed to get clock for clocksource\n");
-                return;
+                return PTR_ERR(clk);
        }
+        ret = -ENXIO;
        base[REG_CH] = of_iomap(node, 0);
        if (!base[REG_CH]) {
                pr_err("failed to map registers for clocksource\n");
@@ -151,6 +152,7 @@ static void __init h8300_16timer_init(struct device_node *node)
                goto unmap_ch;
        }
+        ret = -EINVAL;
        irq = irq_of_parse_and_map(node, 0);
        if (!irq) {
                pr_err("failed to get irq for clockevent\n");
@@ -174,7 +176,7 @@ static void __init h8300_16timer_init(struct device_node *node)
        clocksource_register_hz(&timer16_priv.cs,
                                clk_get_rate(clk) / 8);
-        return;
+        return 0;
 unmap_comm:
        iounmap(base[REG_COMM]);
@@ -182,6 +184,8 @@ unmap_ch:
        iounmap(base[REG_CH]);
 free_clk:
        clk_put(clk);
+        return ret;
 }
-CLOCKSOURCE_OF_DECLARE(h8300_16bit, "renesas,16bit-timer", h8300_16timer_init);
+CLOCKSOURCE_OF_DECLARE(h8300_16bit, "renesas,16bit-timer",
+                           h8300_16timer_init);
diff --git a/drivers/clocksource/h8300_timer8.c b/drivers/clocksource/h8300_timer8.c
index c151941e1956..546bb180f5a4 100644
--- a/drivers/clocksource/h8300_timer8.c
+++ b/drivers/clocksource/h8300_timer8.c
@@ -164,24 +164,26 @@ static struct timer8_priv timer8_priv = {
        },
 };
-static void __init h8300_8timer_init(struct device_node *node)
+static int __init h8300_8timer_init(struct device_node *node)
 {
        void __iomem *base;
-        int irq;
+        int irq, ret;
        struct clk *clk;
        clk = of_clk_get(node, 0);
        if (IS_ERR(clk)) {
                pr_err("failed to get clock for clockevent\n");
-                return;
+                return PTR_ERR(clk);
        }
+        ret = ENXIO;
        base = of_iomap(node, 0);
        if (!base) {
                pr_err("failed to map registers for clockevent\n");
                goto free_clk;
        }
+        ret = -EINVAL;
        irq = irq_of_parse_and_map(node, 0);
        if (!irq) {
                pr_err("failed to get irq for clockevent\n");
@@ -205,11 +207,12 @@ static void __init h8300_8timer_init(struct device_node *node)
        clockevents_config_and_register(&timer8_priv.ced,
                                        timer8_priv.rate, 1, 0x0000ffff);
-        return;
+        return 0;
 unmap_reg:
        iounmap(base);
 free_clk:
        clk_put(clk);
+        return ret;
 }
 CLOCKSOURCE_OF_DECLARE(h8300_8bit, "renesas,8bit-timer", h8300_8timer_init);
diff --git a/drivers/clocksource/h8300_tpu.c b/drivers/clocksource/h8300_tpu.c
index d4c1a287c262..7bdf1991c847 100644
--- a/drivers/clocksource/h8300_tpu.c
+++ b/drivers/clocksource/h8300_tpu.c
@@ -119,15 +119,16 @@ static struct tpu_priv tpu_priv = {
 #define CH_L 0
 #define CH_H 1
-static void __init h8300_tpu_init(struct device_node *node)
+static int __init h8300_tpu_init(struct device_node *node)
 {
        void __iomem *base[2];
        struct clk *clk;
+        int ret = -ENXIO;
        clk = of_clk_get(node, 0);
        if (IS_ERR(clk)) {
                pr_err("failed to get clock for clocksource\n");
-                return;
+                return PTR_ERR(clk);
        }
        base[CH_L] = of_iomap(node, CH_L);
@@ -144,14 +145,13 @@ static void __init h8300_tpu_init(struct device_node *node)
        tpu_priv.mapbase1 = base[CH_L];
        tpu_priv.mapbase2 = base[CH_H];
-        clocksource_register_hz(&tpu_priv.cs, clk_get_rate(clk) / 64);
+        return clocksource_register_hz(&tpu_priv.cs, clk_get_rate(clk) / 64);
-        return;
 unmap_L:
        iounmap(base[CH_H]);
 free_clk:
        clk_put(clk);
+        return ret;
 }
 CLOCKSOURCE_OF_DECLARE(h8300_tpu, "renesas,tpu", h8300_tpu_init);
diff --git a/drivers/clocksource/meson6_timer.c b/drivers/clocksource/meson6_timer.c
index 1fa22c4d2d49..52af591a9fc7 100644
--- a/drivers/clocksource/meson6_timer.c
+++ b/drivers/clocksource/meson6_timer.c
@@ -126,18 +126,22 @@ static struct irqaction meson6_timer_irq = {
        .dev_id         = &meson6_clockevent,
 };
-static void __init meson6_timer_init(struct device_node *node)
+static int __init meson6_timer_init(struct device_node *node)
 {
        u32 val;
        int ret, irq;
        timer_base = of_io_request_and_map(node, 0, "meson6-timer");
-        if (IS_ERR(timer_base))
+        if (IS_ERR(timer_base)) {
-                panic("Can't map registers");
+                pr_err("Can't map registers");
+                return -ENXIO;
+        }
        irq = irq_of_parse_and_map(node, 0);
-        if (irq <= 0)
+        if (irq <= 0) {
-                panic("Can't parse IRQ");
+                pr_err("Can't parse IRQ");
+                return -EINVAL;
+        }
        /* Set 1us for timer E */
        val = readl(timer_base + TIMER_ISA_MUX);
@@ -158,14 +162,17 @@ static void __init meson6_timer_init(struct device_node *node)
        meson6_clkevt_time_stop(CED_ID);
        ret = setup_irq(irq, &meson6_timer_irq);
-        if (ret)
+        if (ret) {
                pr_warn("failed to setup irq %d\n", irq);
+                return ret;
+        }
        meson6_clockevent.cpumask = cpu_possible_mask;
        meson6_clockevent.irq = irq;
        clockevents_config_and_register(&meson6_clockevent, USEC_PER_SEC,
                                        1, 0xfffe);
+        return 0;
 }
 CLOCKSOURCE_OF_DECLARE(meson6, "amlogic,meson6-timer",
                       meson6_timer_init);
diff --git a/drivers/clocksource/mips-gic-timer.c b/drivers/clocksource/mips-gic-timer.c
index 89d3e4d7900c..1572c7a778ab 100644
--- a/drivers/clocksource/mips-gic-timer.c
+++ b/drivers/clocksource/mips-gic-timer.c
@@ -146,7 +146,7 @@ static struct clocksource gic_clocksource = {
        .archdata       = { .vdso_clock_mode = VDSO_CLOCK_GIC },
 };
-static void __init __gic_clocksource_init(void)
+static int __init __gic_clocksource_init(void)
 {
        int ret;
@@ -159,6 +159,8 @@ static void __init __gic_clocksource_init(void)
        ret = clocksource_register_hz(&gic_clocksource, gic_frequency);
        if (ret < 0)
                pr_warn("GIC: Unable to register clocksource\n");
+        return ret;
 }
 void __init gic_clocksource_init(unsigned int frequency)
@@ -179,31 +181,35 @@ static void __init gic_clocksource_of_init(struct device_node *node)
        struct clk *clk;
        int ret;
-        if (WARN_ON(!gic_present || !node->parent ||
+        if (!gic_present || !node->parent ||
-                    !of_device_is_compatible(node->parent, "mti,gic")))
+            !of_device_is_compatible(node->parent, "mti,gic")) {
-                return;
+                pr_warn("No DT definition for the mips gic driver");
+                return -ENXIO;
+        }
        clk = of_clk_get(node, 0);
        if (!IS_ERR(clk)) {
                if (clk_prepare_enable(clk) < 0) {
                        pr_err("GIC failed to enable clock\n");
                        clk_put(clk);
-                        return;
+                        return PTR_ERR(clk);
                }
                gic_frequency = clk_get_rate(clk);
        } else if (of_property_read_u32(node, "clock-frequency",
                                        &gic_frequency)) {
                pr_err("GIC frequency not specified.\n");
-                return;
+                return -EINVAL;;
        }
        gic_timer_irq = irq_of_parse_and_map(node, 0);
        if (!gic_timer_irq) {
                pr_err("GIC timer IRQ not specified.\n");
-                return;
+                return -EINVAL;;
        }
-        __gic_clocksource_init();
+        ret = __gic_clocksource_init();
+        if (ret)
+                return ret;
        ret = gic_clockevent_init();
        if (!ret && !IS_ERR(clk)) {
@@ -213,6 +219,8 @@ static void __init gic_clocksource_of_init(struct device_node *node)
        /* And finally start the counter */
        gic_start_count();
+        return 0;
 }
 CLOCKSOURCE_OF_DECLARE(mips_gic_timer, "mti,gic-timer",
                       gic_clocksource_of_init);
diff --git a/drivers/clocksource/moxart_timer.c b/drivers/clocksource/moxart_timer.c
index 19857af651c1..841454417acd 100644
--- a/drivers/clocksource/moxart_timer.c
+++ b/drivers/clocksource/moxart_timer.c
@@ -119,34 +119,45 @@ static struct irqaction moxart_timer_irq = {
        .dev_id         = &moxart_clockevent,
 };
-static void __init moxart_timer_init(struct device_node *node)
+static int __init moxart_timer_init(struct device_node *node)
 {
        int ret, irq;
        unsigned long pclk;
        struct clk *clk;
        base = of_iomap(node, 0);
-        if (!base)
+        if (!base) {
-                panic("%s: of_iomap failed\n", node->full_name);
+                pr_err("%s: of_iomap failed\n", node->full_name);
+                return -ENXIO;
+        }
        irq = irq_of_parse_and_map(node, 0);
-        if (irq <= 0)
+        if (irq <= 0) {
-                panic("%s: irq_of_parse_and_map failed\n", node->full_name);
+                pr_err("%s: irq_of_parse_and_map failed\n", node->full_name);
+                return -EINVAL;
+        }
        ret = setup_irq(irq, &moxart_timer_irq);
-        if (ret)
+        if (ret) {
-                panic("%s: setup_irq failed\n", node->full_name);
+                pr_err("%s: setup_irq failed\n", node->full_name);
+                return ret;
+        }
        clk = of_clk_get(node, 0);
-        if (IS_ERR(clk))
+        if (IS_ERR(clk))  {
-                panic("%s: of_clk_get failed\n", node->full_name);
+                pr_err("%s: of_clk_get failed\n", node->full_name);
+                return PTR_ERR(clk);
+        }
        pclk = clk_get_rate(clk);
-        if (clocksource_mmio_init(base + TIMER2_BASE + REG_COUNT,
+        ret = clocksource_mmio_init(base + TIMER2_BASE + REG_COUNT,
-                                  "moxart_timer", pclk, 200, 32,
+                                    "moxart_timer", pclk, 200, 32,
-                                  clocksource_mmio_readl_down))
+                                    clocksource_mmio_readl_down);
-                panic("%s: clocksource_mmio_init failed\n", node->full_name);
+        if (ret) {
+                pr_err("%s: clocksource_mmio_init failed\n", node->full_name);
+                return ret;
+        }
        clock_count_per_tick = DIV_ROUND_CLOSEST(pclk, HZ);
@@ -164,5 +175,7 @@ static void __init moxart_timer_init(struct device_node *node)
         */
        clockevents_config_and_register(&moxart_clockevent, pclk,
                                        0x4, 0xfffffffe);
+        return 0;
 }
 CLOCKSOURCE_OF_DECLARE(moxart, "moxa,moxart-timer", moxart_timer_init);
diff --git a/drivers/clocksource/mps2-timer.c b/drivers/clocksource/mps2-timer.c
index 3d33a5e23dee..3e4431ed9aa9 100644
--- a/drivers/clocksource/mps2-timer.c
+++ b/drivers/clocksource/mps2-timer.c
@@ -250,7 +250,7 @@ out:
        return ret;
 }
-static void __init mps2_timer_init(struct device_node *np)
+static int __init mps2_timer_init(struct device_node *np)
 {
        static int has_clocksource, has_clockevent;
        int ret;
@@ -259,7 +259,7 @@ static void __init mps2_timer_init(struct device_node *np)
                ret = mps2_clocksource_init(np);
                if (!ret) {
                        has_clocksource = 1;
-                        return;
+                        return 0;
                }
        }
@@ -267,9 +267,11 @@ static void __init mps2_timer_init(struct device_node *np)
                ret = mps2_clockevent_init(np);
                if (!ret) {
                        has_clockevent = 1;
-                        return;
+                        return 0;
                }
        }
+        return 0;
 }
 CLOCKSOURCE_OF_DECLARE(mps2_timer, "arm,mps2-timer", mps2_timer_init);
diff --git a/drivers/clocksource/mtk_timer.c b/drivers/clocksource/mtk_timer.c
index 7e583f8ea5f4..90659493c59c 100644
--- a/drivers/clocksource/mtk_timer.c
+++ b/drivers/clocksource/mtk_timer.c
@@ -181,7 +181,7 @@ static void mtk_timer_enable_irq(struct mtk_clock_event_device *evt, u8 timer)
                        evt->gpt_base + GPT_IRQ_EN_REG);
 }
-static void __init mtk_timer_init(struct device_node *node)
+static int __init mtk_timer_init(struct device_node *node)
 {
        struct mtk_clock_event_device *evt;
        struct resource res;
@@ -190,7 +190,7 @@ static void __init mtk_timer_init(struct device_node *node)
        evt = kzalloc(sizeof(*evt), GFP_KERNEL);
        if (!evt)
-                return;
+                return -ENOMEM;
        evt->dev.name = "mtk_tick";
        evt->dev.rating = 300;
@@ -248,7 +248,7 @@ static void __init mtk_timer_init(struct device_node *node)
        mtk_timer_enable_irq(evt, GPT_CLK_EVT);
-        return;
+        return 0;
 err_clk_disable:
        clk_disable_unprepare(clk);
@@ -262,5 +262,7 @@ err_mem:
        release_mem_region(res.start, resource_size(&res));
 err_kzalloc:
        kfree(evt);
+        return -EINVAL;
 }
 CLOCKSOURCE_OF_DECLARE(mtk_mt6577, "mediatek,mt6577-timer", mtk_timer_init);
diff --git a/drivers/clocksource/mxs_timer.c b/drivers/clocksource/mxs_timer.c
index f5ce2961c0d6..0ba0a913b41d 100644
--- a/drivers/clocksource/mxs_timer.c
+++ b/drivers/clocksource/mxs_timer.c
@@ -31,8 +31,6 @@
 #include <linux/stmp_device.h>
 #include <linux/sched_clock.h>
-#include <asm/mach/time.h>
 /*
 * There are 2 versions of the timrot on Freescale MXS-based SoCs.
 * The v1 on MX23 only gets 16 bits counter, while v2 on MX28
@@ -226,10 +224,10 @@ static int __init mxs_clocksource_init(struct clk *timer_clk)
        return 0;
 }
-static void __init mxs_timer_init(struct device_node *np)
+static int __init mxs_timer_init(struct device_node *np)
 {
        struct clk *timer_clk;
-        int irq;
+        int irq, ret;
        mxs_timrot_base = of_iomap(np, 0);
        WARN_ON(!mxs_timrot_base);
@@ -237,10 +235,12 @@ static void __init mxs_timer_init(struct device_node *np)
        timer_clk = of_clk_get(np, 0);
        if (IS_ERR(timer_clk)) {
                pr_err("%s: failed to get clk\n", __func__);
-                return;
+                return PTR_ERR(timer_clk);
        }
-        clk_prepare_enable(timer_clk);
+        ret = clk_prepare_enable(timer_clk);
+        if (ret)
+                return ret;
        /*
         * Initialize timers to a known state
@@ -278,11 +278,19 @@ static void __init mxs_timer_init(struct device_node *np)
                        mxs_timrot_base + HW_TIMROT_FIXED_COUNTn(1));
        /* init and register the timer to the framework */
-        mxs_clocksource_init(timer_clk);
+        ret = mxs_clocksource_init(timer_clk);
-        mxs_clockevent_init(timer_clk);
+        if (ret)
+                return ret;
+        ret = mxs_clockevent_init(timer_clk);
+        if (ret)
+                return ret;
        /* Make irqs happen */
        irq = irq_of_parse_and_map(np, 0);
-        setup_irq(irq, &mxs_timer_irq);
+        if (irq <= 0)
+                return -EINVAL;
+        return setup_irq(irq, &mxs_timer_irq);
 }
 CLOCKSOURCE_OF_DECLARE(mxs, "fsl,timrot", mxs_timer_init);
diff --git a/drivers/clocksource/nomadik-mtu.c b/drivers/clocksource/nomadik-mtu.c
index bc8dd443c727..3c124d1ca600 100644
--- a/drivers/clocksource/nomadik-mtu.c
+++ b/drivers/clocksource/nomadik-mtu.c
@@ -193,10 +193,11 @@ static struct irqaction nmdk_timer_irq = {
        .dev_id         = &nmdk_clkevt,
 };
-static void __init nmdk_timer_init(void __iomem *base, int irq,
+static int __init nmdk_timer_init(void __iomem *base, int irq,
                                   struct clk *pclk, struct clk *clk)
 {
        unsigned long rate;
+        int ret;
        mtu_base = base;
@@ -226,10 +227,12 @@ static void __init nmdk_timer_init(void __iomem *base, int irq,
        /* Timer 0 is the free running clocksource */
        nmdk_clksrc_reset();
-        if (clocksource_mmio_init(mtu_base + MTU_VAL(0), "mtu_0",
+        ret = clocksource_mmio_init(mtu_base + MTU_VAL(0), "mtu_0",
-                        rate, 200, 32, clocksource_mmio_readl_down))
+                                    rate, 200, 32, clocksource_mmio_readl_down);
-                pr_err("timer: failed to initialize clock source %s\n",
+        if (ret) {
-                       "mtu_0");
+                pr_err("timer: failed to initialize clock source %s\n", "mtu_0");
+                return ret;
+        }
 #ifdef CONFIG_CLKSRC_NOMADIK_MTU_SCHED_CLOCK
        sched_clock_register(nomadik_read_sched_clock, 32, rate);
@@ -244,9 +247,11 @@ static void __init nmdk_timer_init(void __iomem *base, int irq,
        mtu_delay_timer.read_current_timer = &nmdk_timer_read_current_timer;
        mtu_delay_timer.freq = rate;
        register_current_timer_delay(&mtu_delay_timer);
+        return 0;
 }
-static void __init nmdk_timer_of_init(struct device_node *node)
+static int __init nmdk_timer_of_init(struct device_node *node)
 {
        struct clk *pclk;
        struct clk *clk;
@@ -254,22 +259,30 @@ static void __init nmdk_timer_of_init(struct device_node *node)
        int irq;
        base = of_iomap(node, 0);
-        if (!base)
+        if (!base) {
-                panic("Can't remap registers");
+                pr_err("Can't remap registers");
+                return -ENXIO;
+        }
        pclk = of_clk_get_by_name(node, "apb_pclk");
-        if (IS_ERR(pclk))
+        if (IS_ERR(pclk)) {
-                panic("could not get apb_pclk");
+                pr_err("could not get apb_pclk");
+                return PTR_ERR(pclk);
+        }
        clk = of_clk_get_by_name(node, "timclk");
-        if (IS_ERR(clk))
+        if (IS_ERR(clk)) {
-                panic("could not get timclk");
+                pr_err("could not get timclk");
+                return PTR_ERR(clk);
+        }
        irq = irq_of_parse_and_map(node, 0);
-        if (irq <= 0)
+        if (irq <= 0) {
-                panic("Can't parse IRQ");
+                pr_err("Can't parse IRQ");
+                return -EINVAL;
+        }
-        nmdk_timer_init(base, irq, pclk, clk);
+        return nmdk_timer_init(base, irq, pclk, clk);
 }
 CLOCKSOURCE_OF_DECLARE(nomadik_mtu, "st,nomadik-mtu",
                       nmdk_timer_of_init);
diff --git a/drivers/clocksource/pxa_timer.c b/drivers/clocksource/pxa_timer.c
index 45b6a4999713..937e10b84d58 100644
--- a/drivers/clocksource/pxa_timer.c
+++ b/drivers/clocksource/pxa_timer.c
@@ -150,8 +150,10 @@ static struct irqaction pxa_ost0_irq = {
        .dev_id         = &ckevt_pxa_osmr0,
 };
-static void __init pxa_timer_common_init(int irq, unsigned long clock_tick_rate)
+static int __init pxa_timer_common_init(int irq, unsigned long clock_tick_rate)
 {
+        int ret;
        timer_writel(0, OIER);
        timer_writel(OSSR_M0 | OSSR_M1 | OSSR_M2 | OSSR_M3, OSSR);
@@ -159,39 +161,57 @@ static void __init pxa_timer_common_init(int irq, unsigned long clock_tick_rate)
        ckevt_pxa_osmr0.cpumask = cpumask_of(0);
-        setup_irq(irq, &pxa_ost0_irq);
+        ret = setup_irq(irq, &pxa_ost0_irq);
+        if (ret) {
+                pr_err("Failed to setup irq");
+                return ret;
+        }
+        ret = clocksource_mmio_init(timer_base + OSCR, "oscr0", clock_tick_rate, 200,
+                                    32, clocksource_mmio_readl_up);
+        if (ret) {
+                pr_err("Failed to init clocksource");
+                return ret;
+        }
-        clocksource_mmio_init(timer_base + OSCR, "oscr0", clock_tick_rate, 200,
-                              32, clocksource_mmio_readl_up);
        clockevents_config_and_register(&ckevt_pxa_osmr0, clock_tick_rate,
                                        MIN_OSCR_DELTA * 2, 0x7fffffff);
+        return 0;
 }
-static void __init pxa_timer_dt_init(struct device_node *np)
+static int __init pxa_timer_dt_init(struct device_node *np)
 {
        struct clk *clk;
-        int irq;
+        int irq, ret;
        /* timer registers are shared with watchdog timer */
        timer_base = of_iomap(np, 0);
-        if (!timer_base)
+        if (!timer_base) {
-                panic("%s: unable to map resource\n", np->name);
+                pr_err("%s: unable to map resource\n", np->name);
+                return -ENXIO;
+        }
        clk = of_clk_get(np, 0);
        if (IS_ERR(clk)) {
                pr_crit("%s: unable to get clk\n", np->name);
-                return;
+                return PTR_ERR(clk);
+        }
+        ret = clk_prepare_enable(clk);
+        if (ret) {
+                pr_crit("Failed to prepare clock");
+                return ret;
        }
-        clk_prepare_enable(clk);
        /* we are only interested in OS-timer0 irq */
        irq = irq_of_parse_and_map(np, 0);
        if (irq <= 0) {
                pr_crit("%s: unable to parse OS-timer0 irq\n", np->name);
-                return;
+                return -EINVAL;
        }
-        pxa_timer_common_init(irq, clk_get_rate(clk));
+        return pxa_timer_common_init(irq, clk_get_rate(clk));
 }
 CLOCKSOURCE_OF_DECLARE(pxa_timer, "marvell,pxa-timer", pxa_timer_dt_init);
diff --git a/drivers/clocksource/qcom-timer.c b/drivers/clocksource/qcom-timer.c
index f8e09f923651..662576339049 100644
--- a/drivers/clocksource/qcom-timer.c
+++ b/drivers/clocksource/qcom-timer.c
@@ -178,7 +178,7 @@ static struct delay_timer msm_delay_timer = {
        .read_current_timer = msm_read_current_timer,
 };
-static void __init msm_timer_init(u32 dgt_hz, int sched_bits, int irq,
+static int __init msm_timer_init(u32 dgt_hz, int sched_bits, int irq,
                                  bool percpu)
 {
        struct clocksource *cs = &msm_clocksource;
@@ -218,12 +218,14 @@ err:
        sched_clock_register(msm_sched_clock_read, sched_bits, dgt_hz);
        msm_delay_timer.freq = dgt_hz;
        register_current_timer_delay(&msm_delay_timer);
+        return res;
 }
-static void __init msm_dt_timer_init(struct device_node *np)
+static int __init msm_dt_timer_init(struct device_node *np)
 {
        u32 freq;
-        int irq;
+        int irq, ret;
        struct resource res;
        u32 percpu_offset;
        void __iomem *base;
@@ -232,34 +234,35 @@ static void __init msm_dt_timer_init(struct device_node *np)
        base = of_iomap(np, 0);
        if (!base) {
                pr_err("Failed to map event base\n");
-                return;
+                return -ENXIO;
        }
        /* We use GPT0 for the clockevent */
        irq = irq_of_parse_and_map(np, 1);
        if (irq <= 0) {
                pr_err("Can't get irq\n");
-                return;
+                return -EINVAL;
        }
        /* We use CPU0's DGT for the clocksource */
        if (of_property_read_u32(np, "cpu-offset", &percpu_offset))
                percpu_offset = 0;
-        if (of_address_to_resource(np, 0, &res)) {
+        ret = of_address_to_resource(np, 0, &res);
+        if (ret) {
                pr_err("Failed to parse DGT resource\n");
-                return;
+                return ret;
        }
        cpu0_base = ioremap(res.start + percpu_offset, resource_size(&res));
        if (!cpu0_base) {
                pr_err("Failed to map source base\n");
-                return;
+                return -EINVAL;
        }
        if (of_property_read_u32(np, "clock-frequency", &freq)) {
                pr_err("Unknown frequency\n");
-                return;
+                return -EINVAL;
        }
        event_base = base + 0x4;
@@ -268,7 +271,7 @@ static void __init msm_dt_timer_init(struct device_node *np)
        freq /= 4;
        writel_relaxed(DGT_CLK_CTL_DIV_4, source_base + DGT_CLK_CTL);
-        msm_timer_init(freq, 32, irq, !!percpu_offset);
+        return msm_timer_init(freq, 32, irq, !!percpu_offset);
 }
 CLOCKSOURCE_OF_DECLARE(kpss_timer, "qcom,kpss-timer", msm_dt_timer_init);
 CLOCKSOURCE_OF_DECLARE(scss_timer, "qcom,scss-timer", msm_dt_timer_init);
diff --git a/drivers/clocksource/rockchip_timer.c b/drivers/clocksource/rockchip_timer.c
index b991b288c803..23e267acba25 100644
--- a/drivers/clocksource/rockchip_timer.c
+++ b/drivers/clocksource/rockchip_timer.c
@@ -19,7 +19,8 @@
 #define TIMER_LOAD_COUNT0       0x00
 #define TIMER_LOAD_COUNT1       0x04
-#define TIMER_CONTROL_REG       0x10
+#define TIMER_CONTROL_REG3288   0x10
+#define TIMER_CONTROL_REG3399   0x1c
 #define TIMER_INT_STATUS        0x18
 #define TIMER_DISABLE           0x0
@@ -31,6 +32,7 @@
 struct bc_timer {
        struct clock_event_device ce;
        void __iomem *base;
+        void __iomem *ctrl;
        u32 freq;
 };
@@ -46,15 +48,20 @@ static inline void __iomem *rk_base(struct clock_event_device *ce)
        return rk_timer(ce)->base;
 }
+static inline void __iomem *rk_ctrl(struct clock_event_device *ce)
+{
+        return rk_timer(ce)->ctrl;
+}
 static inline void rk_timer_disable(struct clock_event_device *ce)
 {
-        writel_relaxed(TIMER_DISABLE, rk_base(ce) + TIMER_CONTROL_REG);
+        writel_relaxed(TIMER_DISABLE, rk_ctrl(ce));
 }
 static inline void rk_timer_enable(struct clock_event_device *ce, u32 flags)
 {
        writel_relaxed(TIMER_ENABLE | TIMER_INT_UNMASK | flags,
-                       rk_base(ce) + TIMER_CONTROL_REG);
+                       rk_ctrl(ce));
 }
 static void rk_timer_update_counter(unsigned long cycles,
@@ -106,37 +113,42 @@ static irqreturn_t rk_timer_interrupt(int irq, void *dev_id)
        return IRQ_HANDLED;
 }
-static void __init rk_timer_init(struct device_node *np)
+static int __init rk_timer_init(struct device_node *np, u32 ctrl_reg)
 {
        struct clock_event_device *ce = &bc_timer.ce;
        struct clk *timer_clk;
        struct clk *pclk;
-        int ret, irq;
+        int ret = -EINVAL, irq;
        bc_timer.base = of_iomap(np, 0);
        if (!bc_timer.base) {
                pr_err("Failed to get base address for '%s'\n", TIMER_NAME);
-                return;
+                return -ENXIO;
        }
+        bc_timer.ctrl = bc_timer.base + ctrl_reg;
        pclk = of_clk_get_by_name(np, "pclk");
        if (IS_ERR(pclk)) {
+                ret = PTR_ERR(pclk);
                pr_err("Failed to get pclk for '%s'\n", TIMER_NAME);
                goto out_unmap;
        }
-        if (clk_prepare_enable(pclk)) {
+        ret = clk_prepare_enable(pclk);
+        if (ret) {
                pr_err("Failed to enable pclk for '%s'\n", TIMER_NAME);
                goto out_unmap;
        }
        timer_clk = of_clk_get_by_name(np, "timer");
        if (IS_ERR(timer_clk)) {
+                ret = PTR_ERR(timer_clk);
                pr_err("Failed to get timer clock for '%s'\n", TIMER_NAME);
                goto out_timer_clk;
        }
-        if (clk_prepare_enable(timer_clk)) {
+        ret = clk_prepare_enable(timer_clk);
+        if (ret) {
                pr_err("Failed to enable timer clock\n");
                goto out_timer_clk;
        }
@@ -145,17 +157,19 @@ static void __init rk_timer_init(struct device_node *np)
        irq = irq_of_parse_and_map(np, 0);
        if (!irq) {
+                ret = -EINVAL;
                pr_err("Failed to map interrupts for '%s'\n", TIMER_NAME);
                goto out_irq;
        }
        ce->name = TIMER_NAME;
-        ce->features = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT;
+        ce->features = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT |
+                       CLOCK_EVT_FEAT_DYNIRQ;
        ce->set_next_event = rk_timer_set_next_event;
        ce->set_state_shutdown = rk_timer_shutdown;
        ce->set_state_periodic = rk_timer_set_periodic;
        ce->irq = irq;
-        ce->cpumask = cpumask_of(0);
+        ce->cpumask = cpu_possible_mask;
        ce->rating = 250;
        rk_timer_interrupt_clear(ce);
@@ -169,7 +183,7 @@ static void __init rk_timer_init(struct device_node *np)
        clockevents_config_and_register(ce, bc_timer.freq, 1, UINT_MAX);
-        return;
+        return 0;
 out_irq:
        clk_disable_unprepare(timer_clk);
@@ -177,6 +191,21 @@ out_timer_clk:
        clk_disable_unprepare(pclk);
 out_unmap:
        iounmap(bc_timer.base);
+        return ret;
+}
+static int __init rk3288_timer_init(struct device_node *np)
+{
+        return rk_timer_init(np, TIMER_CONTROL_REG3288);
+}
+static int __init rk3399_timer_init(struct device_node *np)
+{
+        return rk_timer_init(np, TIMER_CONTROL_REG3399);
 }
-CLOCKSOURCE_OF_DECLARE(rk_timer, "rockchip,rk3288-timer", rk_timer_init);
+CLOCKSOURCE_OF_DECLARE(rk3288_timer, "rockchip,rk3288-timer",
+                       rk3288_timer_init);
+CLOCKSOURCE_OF_DECLARE(rk3399_timer, "rockchip,rk3399-timer",
+                       rk3399_timer_init);
diff --git a/drivers/clocksource/samsung_pwm_timer.c b/drivers/clocksource/samsung_pwm_timer.c
index 9502bc4c3f6d..54565bd0093b 100644
--- a/drivers/clocksource/samsung_pwm_timer.c
+++ b/drivers/clocksource/samsung_pwm_timer.c
@@ -130,9 +130,9 @@ static void samsung_time_stop(unsigned int channel)
        spin_lock_irqsave(&samsung_pwm_lock, flags);
-        tcon = __raw_readl(pwm.base + REG_TCON);
+        tcon = readl_relaxed(pwm.base + REG_TCON);
        tcon &= ~TCON_START(channel);
-        __raw_writel(tcon, pwm.base + REG_TCON);
+        writel_relaxed(tcon, pwm.base + REG_TCON);
        spin_unlock_irqrestore(&samsung_pwm_lock, flags);
 }
@@ -148,14 +148,14 @@ static void samsung_time_setup(unsigned int channel, unsigned long tcnt)
        spin_lock_irqsave(&samsung_pwm_lock, flags);
-        tcon = __raw_readl(pwm.base + REG_TCON);
+        tcon = readl_relaxed(pwm.base + REG_TCON);
        tcon &= ~(TCON_START(tcon_chan) | TCON_AUTORELOAD(tcon_chan));
        tcon |= TCON_MANUALUPDATE(tcon_chan);
-        __raw_writel(tcnt, pwm.base + REG_TCNTB(channel));
+        writel_relaxed(tcnt, pwm.base + REG_TCNTB(channel));
-        __raw_writel(tcnt, pwm.base + REG_TCMPB(channel));
+        writel_relaxed(tcnt, pwm.base + REG_TCMPB(channel));
-        __raw_writel(tcon, pwm.base + REG_TCON);
+        writel_relaxed(tcon, pwm.base + REG_TCON);
        spin_unlock_irqrestore(&samsung_pwm_lock, flags);
 }
@@ -170,7 +170,7 @@ static void samsung_time_start(unsigned int channel, bool periodic)
        spin_lock_irqsave(&samsung_pwm_lock, flags);
-        tcon = __raw_readl(pwm.base + REG_TCON);
+        tcon = readl_relaxed(pwm.base + REG_TCON);
        tcon &= ~TCON_MANUALUPDATE(channel);
        tcon |= TCON_START(channel);
@@ -180,7 +180,7 @@ static void samsung_time_start(unsigned int channel, bool periodic)
        else
                tcon &= ~TCON_AUTORELOAD(channel);
-        __raw_writel(tcon, pwm.base + REG_TCON);
+        writel_relaxed(tcon, pwm.base + REG_TCON);
        spin_unlock_irqrestore(&samsung_pwm_lock, flags);
 }
@@ -333,11 +333,10 @@ static u64 notrace samsung_read_sched_clock(void)
        return samsung_clocksource_read(NULL);
 }
-static void __init samsung_clocksource_init(void)
+static int __init samsung_clocksource_init(void)
 {
        unsigned long pclk;
        unsigned long clock_rate;
-        int ret;
        pclk = clk_get_rate(pwm.timerclk);
@@ -358,9 +357,7 @@ static void __init samsung_clocksource_init(void)
                                                pwm.variant.bits, clock_rate);
        samsung_clocksource.mask = CLOCKSOURCE_MASK(pwm.variant.bits);
-        ret = clocksource_register_hz(&samsung_clocksource, clock_rate);
+        return clocksource_register_hz(&samsung_clocksource, clock_rate);
-        if (ret)
-                panic("samsung_clocksource_timer: can't register clocksource\n");
 }
 static void __init samsung_timer_resources(void)
@@ -380,26 +377,31 @@ static void __init samsung_timer_resources(void)
 /*
 * PWM master driver
 */
-static void __init _samsung_pwm_clocksource_init(void)
+static int __init _samsung_pwm_clocksource_init(void)
 {
        u8 mask;
        int channel;
        mask = ~pwm.variant.output_mask & ((1 << SAMSUNG_PWM_NUM) - 1);
        channel = fls(mask) - 1;
-        if (channel < 0)
+        if (channel < 0) {
-                panic("failed to find PWM channel for clocksource");
+                pr_crit("failed to find PWM channel for clocksource");
+                return -EINVAL;
+        }
        pwm.source_id = channel;
        mask &= ~(1 << channel);
        channel = fls(mask) - 1;
-        if (channel < 0)
+        if (channel < 0) {
-                panic("failed to find PWM channel for clock event");
+                pr_crit("failed to find PWM channel for clock event");
+                return -EINVAL;
+        }
        pwm.event_id = channel;
        samsung_timer_resources();
        samsung_clockevent_init();
-        samsung_clocksource_init();
+        return samsung_clocksource_init();
 }
 void __init samsung_pwm_clocksource_init(void __iomem *base,
@@ -417,8 +419,8 @@ void __init samsung_pwm_clocksource_init(void __iomem *base,
 }
 #ifdef CONFIG_CLKSRC_OF
-static void __init samsung_pwm_alloc(struct device_node *np,
+static int __init samsung_pwm_alloc(struct device_node *np,
-                                     const struct samsung_pwm_variant *variant)
+                                    const struct samsung_pwm_variant *variant)
 {
        struct property *prop;
        const __be32 *cur;
@@ -441,14 +443,16 @@ static void __init samsung_pwm_alloc(struct device_node *np,
        pwm.base = of_iomap(np, 0);
        if (!pwm.base) {
                pr_err("%s: failed to map PWM registers\n", __func__);
-                return;
+                return -ENXIO;
        }
        pwm.timerclk = of_clk_get_by_name(np, "timers");
-        if (IS_ERR(pwm.timerclk))
+        if (IS_ERR(pwm.timerclk)) {
-                panic("failed to get timers clock for timer");
+                pr_crit("failed to get timers clock for timer");
+                return PTR_ERR(pwm.timerclk);
+        }
-        _samsung_pwm_clocksource_init();
+        return _samsung_pwm_clocksource_init();
 }
 static const struct samsung_pwm_variant s3c24xx_variant = {
@@ -458,9 +462,9 @@ static const struct samsung_pwm_variant s3c24xx_variant = {
        .tclk_mask      = (1 << 4),
 };
-static void __init s3c2410_pwm_clocksource_init(struct device_node *np)
+static int __init s3c2410_pwm_clocksource_init(struct device_node *np)
 {
-        samsung_pwm_alloc(np, &s3c24xx_variant);
+        return samsung_pwm_alloc(np, &s3c24xx_variant);
 }
 CLOCKSOURCE_OF_DECLARE(s3c2410_pwm, "samsung,s3c2410-pwm", s3c2410_pwm_clocksource_init);
@@ -471,9 +475,9 @@ static const struct samsung_pwm_variant s3c64xx_variant = {
        .tclk_mask      = (1 << 7) | (1 << 6) | (1 << 5),
 };
-static void __init s3c64xx_pwm_clocksource_init(struct device_node *np)
+static int __init s3c64xx_pwm_clocksource_init(struct device_node *np)
 {
-        samsung_pwm_alloc(np, &s3c64xx_variant);
+        return samsung_pwm_alloc(np, &s3c64xx_variant);
 }
 CLOCKSOURCE_OF_DECLARE(s3c6400_pwm, "samsung,s3c6400-pwm", s3c64xx_pwm_clocksource_init);
@@ -484,9 +488,9 @@ static const struct samsung_pwm_variant s5p64x0_variant = {
        .tclk_mask      = 0,
 };
-static void __init s5p64x0_pwm_clocksource_init(struct device_node *np)
+static int __init s5p64x0_pwm_clocksource_init(struct device_node *np)
 {
-        samsung_pwm_alloc(np, &s5p64x0_variant);
+        return samsung_pwm_alloc(np, &s5p64x0_variant);
 }
 CLOCKSOURCE_OF_DECLARE(s5p6440_pwm, "samsung,s5p6440-pwm", s5p64x0_pwm_clocksource_init);
@@ -497,9 +501,9 @@ static const struct samsung_pwm_variant s5p_variant = {
        .tclk_mask      = (1 << 5),
 };
-static void __init s5p_pwm_clocksource_init(struct device_node *np)
+static int __init s5p_pwm_clocksource_init(struct device_node *np)
 {
-        samsung_pwm_alloc(np, &s5p_variant);
+        return samsung_pwm_alloc(np, &s5p_variant);
 }
 CLOCKSOURCE_OF_DECLARE(s5pc100_pwm, "samsung,s5pc100-pwm", s5p_pwm_clocksource_init);
 #endif
diff --git a/drivers/clocksource/sun4i_timer.c b/drivers/clocksource/sun4i_timer.c
index 6f3719d73390..97669ee4df2a 100644
--- a/drivers/clocksource/sun4i_timer.c
+++ b/drivers/clocksource/sun4i_timer.c
@@ -146,7 +146,7 @@ static u64 notrace sun4i_timer_sched_read(void)
        return ~readl(timer_base + TIMER_CNTVAL_REG(1));
 }
-static void __init sun4i_timer_init(struct device_node *node)
+static int __init sun4i_timer_init(struct device_node *node)
 {
        unsigned long rate = 0;
        struct clk *clk;
@@ -154,17 +154,28 @@ static void __init sun4i_timer_init(struct device_node *node)
        u32 val;
        timer_base = of_iomap(node, 0);
-        if (!timer_base)
+        if (!timer_base) {
-                panic("Can't map registers");
+                pr_crit("Can't map registers");
+                return -ENXIO;
+        }
        irq = irq_of_parse_and_map(node, 0);
-        if (irq <= 0)
+        if (irq <= 0) {
-                panic("Can't parse IRQ");
+                pr_crit("Can't parse IRQ");
+                return -EINVAL;
+        }
        clk = of_clk_get(node, 0);
-        if (IS_ERR(clk))
+        if (IS_ERR(clk)) {
-                panic("Can't get timer clock");
+                pr_crit("Can't get timer clock");
-        clk_prepare_enable(clk);
+                return PTR_ERR(clk);
+        }
+        ret = clk_prepare_enable(clk);
+        if (ret) {
+                pr_err("Failed to prepare clock");
+                return ret;
+        }
        rate = clk_get_rate(clk);
@@ -182,8 +193,12 @@ static void __init sun4i_timer_init(struct device_node *node)
            of_machine_is_compatible("allwinner,sun5i-a10s"))
                sched_clock_register(sun4i_timer_sched_read, 32, rate);
-        clocksource_mmio_init(timer_base + TIMER_CNTVAL_REG(1), node->name,
+        ret = clocksource_mmio_init(timer_base + TIMER_CNTVAL_REG(1), node->name,
-                              rate, 350, 32, clocksource_mmio_readl_down);
+                                    rate, 350, 32, clocksource_mmio_readl_down);
+        if (ret) {
+                pr_err("Failed to register clocksource");
+                return ret;
+        }
        ticks_per_jiffy = DIV_ROUND_UP(rate, HZ);
@@ -200,12 +215,16 @@ static void __init sun4i_timer_init(struct device_node *node)
                                        TIMER_SYNC_TICKS, 0xffffffff);
        ret = setup_irq(irq, &sun4i_timer_irq);
-        if (ret)
+        if (ret) {
-                pr_warn("failed to setup irq %d\n", irq);
+                pr_err("failed to setup irq %d\n", irq);
+                return ret;
+        }
        /* Enable timer0 interrupt */
        val = readl(timer_base + TIMER_IRQ_EN_REG);
        writel(val | TIMER_IRQ_EN(0), timer_base + TIMER_IRQ_EN_REG);
+        return ret;
 }
 CLOCKSOURCE_OF_DECLARE(sun4i, "allwinner,sun4i-a10-timer",
                       sun4i_timer_init);
diff --git a/drivers/clocksource/tango_xtal.c b/drivers/clocksource/tango_xtal.c
index c407c47a3232..12fcef8cf2d3 100644
--- a/drivers/clocksource/tango_xtal.c
+++ b/drivers/clocksource/tango_xtal.c
@@ -19,7 +19,7 @@ static u64 notrace read_sched_clock(void)
        return read_xtal_counter();
 }
-static void __init tango_clocksource_init(struct device_node *np)
+static int __init tango_clocksource_init(struct device_node *np)
 {
        struct clk *clk;
        int xtal_freq, ret;
@@ -27,13 +27,13 @@ static void __init tango_clocksource_init(struct device_node *np)
        xtal_in_cnt = of_iomap(np, 0);
        if (xtal_in_cnt == NULL) {
                pr_err("%s: invalid address\n", np->full_name);
-                return;
+                return -ENXIO;
        }
        clk = of_clk_get(np, 0);
        if (IS_ERR(clk)) {
                pr_err("%s: invalid clock\n", np->full_name);
-                return;
+                return PTR_ERR(clk);
        }
        xtal_freq = clk_get_rate(clk);
@@ -44,11 +44,13 @@ static void __init tango_clocksource_init(struct device_node *np)
                                    32, clocksource_mmio_readl_up);
        if (ret) {
                pr_err("%s: registration failed\n", np->full_name);
-                return;
+                return ret;
        }
        sched_clock_register(read_sched_clock, 32, xtal_freq);
        register_current_timer_delay(&delay_timer);
+        return 0;
 }
 CLOCKSOURCE_OF_DECLARE(tango, "sigma,tick-counter", tango_clocksource_init);
diff --git a/drivers/clocksource/tegra20_timer.c b/drivers/clocksource/tegra20_timer.c
index 7b94ad2ab278..f960891aa04e 100644
--- a/drivers/clocksource/tegra20_timer.c
+++ b/drivers/clocksource/tegra20_timer.c
@@ -165,7 +165,7 @@ static struct irqaction tegra_timer_irq = {
        .dev_id         = &tegra_clockevent,
 };
-static void __init tegra20_init_timer(struct device_node *np)
+static int __init tegra20_init_timer(struct device_node *np)
 {
        struct clk *clk;
        unsigned long rate;
@@ -174,13 +174,13 @@ static void __init tegra20_init_timer(struct device_node *np)
        timer_reg_base = of_iomap(np, 0);
        if (!timer_reg_base) {
                pr_err("Can't map timer registers\n");
-                BUG();
+                return -ENXIO;
        }
        tegra_timer_irq.irq = irq_of_parse_and_map(np, 2);
        if (tegra_timer_irq.irq <= 0) {
                pr_err("Failed to map timer IRQ\n");
-                BUG();
+                return -EINVAL;
        }
        clk = of_clk_get(np, 0);
@@ -211,10 +211,12 @@ static void __init tegra20_init_timer(struct device_node *np)
        sched_clock_register(tegra_read_sched_clock, 32, 1000000);
-        if (clocksource_mmio_init(timer_reg_base + TIMERUS_CNTR_1US,
+        ret = clocksource_mmio_init(timer_reg_base + TIMERUS_CNTR_1US,
-                "timer_us", 1000000, 300, 32, clocksource_mmio_readl_up)) {
+                                    "timer_us", 1000000, 300, 32,
+                                    clocksource_mmio_readl_up);
+        if (ret) {
                pr_err("Failed to register clocksource\n");
-                BUG();
+                return ret;
        }
        tegra_delay_timer.read_current_timer =
@@ -225,24 +227,26 @@ static void __init tegra20_init_timer(struct device_node *np)
        ret = setup_irq(tegra_timer_irq.irq, &tegra_timer_irq);
        if (ret) {
                pr_err("Failed to register timer IRQ: %d\n", ret);
-                BUG();
+                return ret;
        }
        tegra_clockevent.cpumask = cpu_all_mask;
        tegra_clockevent.irq = tegra_timer_irq.irq;
        clockevents_config_and_register(&tegra_clockevent, 1000000,
                                        0x1, 0x1fffffff);
+        return 0;
 }
 CLOCKSOURCE_OF_DECLARE(tegra20_timer, "nvidia,tegra20-timer", tegra20_init_timer);
-static void __init tegra20_init_rtc(struct device_node *np)
+static int __init tegra20_init_rtc(struct device_node *np)
 {
        struct clk *clk;
        rtc_base = of_iomap(np, 0);
        if (!rtc_base) {
                pr_err("Can't map RTC registers");
-                BUG();
+                return -ENXIO;
        }
        /*
@@ -255,6 +259,6 @@ static void __init tegra20_init_rtc(struct device_node *np)
        else
                clk_prepare_enable(clk);
-        register_persistent_clock(NULL, tegra_read_persistent_clock64);
+        return register_persistent_clock(NULL, tegra_read_persistent_clock64);
 }
 CLOCKSOURCE_OF_DECLARE(tegra20_rtc, "nvidia,tegra20-rtc", tegra20_init_rtc);
diff --git a/drivers/clocksource/time-armada-370-xp.c b/drivers/clocksource/time-armada-370-xp.c
index d93ec3c4f139..20ec066481fe 100644
--- a/drivers/clocksource/time-armada-370-xp.c
+++ b/drivers/clocksource/time-armada-370-xp.c
@@ -246,7 +246,7 @@ static void armada_370_xp_timer_resume(void)
        writel(timer0_local_ctrl_reg, local_base + TIMER_CTRL_OFF);
 }
-struct syscore_ops armada_370_xp_timer_syscore_ops = {
+static struct syscore_ops armada_370_xp_timer_syscore_ops = {
        .suspend        = armada_370_xp_timer_suspend,
        .resume         = armada_370_xp_timer_resume,
 };
@@ -260,14 +260,22 @@ static struct delay_timer armada_370_delay_timer = {
        .read_current_timer = armada_370_delay_timer_read,
 };
-static void __init armada_370_xp_timer_common_init(struct device_node *np)
+static int __init armada_370_xp_timer_common_init(struct device_node *np)
 {
        u32 clr = 0, set = 0;
        int res;
        timer_base = of_iomap(np, 0);
-        WARN_ON(!timer_base);
+        if (!timer_base) {
+                pr_err("Failed to iomap");
+                return -ENXIO;
+        }
        local_base = of_iomap(np, 1);
+        if (!local_base) {
+                pr_err("Failed to iomap");
+                return -ENXIO;
+        }
        if (timer25Mhz) {
                set = TIMER0_25MHZ;             
@@ -306,14 +314,19 @@ static void __init armada_370_xp_timer_common_init(struct device_node *np)
         */
        sched_clock_register(armada_370_xp_read_sched_clock, 32, timer_clk);
-        clocksource_mmio_init(timer_base + TIMER0_VAL_OFF,
+        res = clocksource_mmio_init(timer_base + TIMER0_VAL_OFF,
-                              "armada_370_xp_clocksource",
+                                    "armada_370_xp_clocksource",
-                              timer_clk, 300, 32, clocksource_mmio_readl_down);
+                                    timer_clk, 300, 32, clocksource_mmio_readl_down);
+        if (res) {
+                pr_err("Failed to initialize clocksource mmio");
+                return res;
+        }
        register_cpu_notifier(&armada_370_xp_timer_cpu_nb);
        armada_370_xp_evt = alloc_percpu(struct clock_event_device);
+        if (!armada_370_xp_evt)
+                return -ENOMEM;
        /*
         * Setup clockevent timer (interrupt-driven).
@@ -323,33 +336,54 @@ static void __init armada_370_xp_timer_common_init(struct device_node *np)
                                "armada_370_xp_per_cpu_tick",
                                armada_370_xp_evt);
        /* Immediately configure the timer on the boot CPU */
-        if (!res)
+        if (res) {
-                armada_370_xp_timer_setup(this_cpu_ptr(armada_370_xp_evt));
+                pr_err("Failed to request percpu irq");
+                return res;
+        }
+        res = armada_370_xp_timer_setup(this_cpu_ptr(armada_370_xp_evt));
+        if (res) {
+                pr_err("Failed to setup timer");
+                return res;
+        }
        register_syscore_ops(&armada_370_xp_timer_syscore_ops);
+        
+        return 0;
 }
-static void __init armada_xp_timer_init(struct device_node *np)
+static int __init armada_xp_timer_init(struct device_node *np)
 {
        struct clk *clk = of_clk_get_by_name(np, "fixed");
+        int ret;
+        clk = of_clk_get(np, 0);
+        if (IS_ERR(clk)) {
+                pr_err("Failed to get clock");
+                return PTR_ERR(clk);
+        }
+        ret = clk_prepare_enable(clk);
+        if (ret)
+                return ret;
-        /* The 25Mhz fixed clock is mandatory, and must always be available */
-        BUG_ON(IS_ERR(clk));
-        clk_prepare_enable(clk);
        timer_clk = clk_get_rate(clk);
-        armada_370_xp_timer_common_init(np);
+        return armada_370_xp_timer_common_init(np);
 }
 CLOCKSOURCE_OF_DECLARE(armada_xp, "marvell,armada-xp-timer",
                       armada_xp_timer_init);
-static void __init armada_375_timer_init(struct device_node *np)
+static int __init armada_375_timer_init(struct device_node *np)
 {
        struct clk *clk;
+        int ret;
        clk = of_clk_get_by_name(np, "fixed");
        if (!IS_ERR(clk)) {
-                clk_prepare_enable(clk);
+                ret = clk_prepare_enable(clk);
+                if (ret)
+                        return ret;
                timer_clk = clk_get_rate(clk);
        } else {
@@ -360,27 +394,43 @@ static void __init armada_375_timer_init(struct device_node *np)
                clk = of_clk_get(np, 0);
                /* Must have at least a clock */
-                BUG_ON(IS_ERR(clk));
+                if (IS_ERR(clk)) {
-                clk_prepare_enable(clk);
+                        pr_err("Failed to get clock");
+                        return PTR_ERR(clk);
+                }
+                ret = clk_prepare_enable(clk);
+                if (ret)
+                        return ret;
                timer_clk = clk_get_rate(clk) / TIMER_DIVIDER;
                timer25Mhz = false;
        }
-        armada_370_xp_timer_common_init(np);
+        return armada_370_xp_timer_common_init(np);
 }
 CLOCKSOURCE_OF_DECLARE(armada_375, "marvell,armada-375-timer",
                       armada_375_timer_init);
-static void __init armada_370_timer_init(struct device_node *np)
+static int __init armada_370_timer_init(struct device_node *np)
 {
-        struct clk *clk = of_clk_get(np, 0);
+        struct clk *clk;
+        int ret;
+        clk = of_clk_get(np, 0);
+        if (IS_ERR(clk)) {
+                pr_err("Failed to get clock");
+                return PTR_ERR(clk);
+        }
+        ret = clk_prepare_enable(clk);
+        if (ret)
+                return ret;
-        BUG_ON(IS_ERR(clk));
-        clk_prepare_enable(clk);
        timer_clk = clk_get_rate(clk) / TIMER_DIVIDER;
        timer25Mhz = false;
-        armada_370_xp_timer_common_init(np);
+        return armada_370_xp_timer_common_init(np);
 }
 CLOCKSOURCE_OF_DECLARE(armada_370, "marvell,armada-370-timer",
                       armada_370_timer_init);
diff --git a/drivers/clocksource/time-efm32.c b/drivers/clocksource/time-efm32.c
index b06e4c2be406..5ac344b383e1 100644
--- a/drivers/clocksource/time-efm32.c
+++ b/drivers/clocksource/time-efm32.c
@@ -233,10 +233,15 @@ static int __init efm32_clockevent_init(struct device_node *np)
                                        DIV_ROUND_CLOSEST(rate, 1024),
                                        0xf, 0xffff);
-        setup_irq(irq, &efm32_clock_event_irq);
+        ret = setup_irq(irq, &efm32_clock_event_irq);
+        if (ret) {
+                pr_err("Failed setup irq");
+                goto err_setup_irq;
+        }
        return 0;
+err_setup_irq:
 err_get_irq:
        iounmap(base);
@@ -255,16 +260,16 @@ err_clk_get:
 * This function asserts that we have exactly one clocksource and one
 * clock_event_device in the end.
 */
-static void __init efm32_timer_init(struct device_node *np)
+static int __init efm32_timer_init(struct device_node *np)
 {
        static int has_clocksource, has_clockevent;
-        int ret;
+        int ret = 0;
        if (!has_clocksource) {
                ret = efm32_clocksource_init(np);
                if (!ret) {
                        has_clocksource = 1;
-                        return;
+                        return 0;
                }
        }
@@ -272,9 +277,11 @@ static void __init efm32_timer_init(struct device_node *np)
                ret = efm32_clockevent_init(np);
                if (!ret) {
                        has_clockevent = 1;
-                        return;
+                        return 0;
                }
        }
+        return ret;
 }
 CLOCKSOURCE_OF_DECLARE(efm32compat, "efm32,timer", efm32_timer_init);
 CLOCKSOURCE_OF_DECLARE(efm32, "energymicro,efm32-timer", efm32_timer_init);
diff --git a/drivers/clocksource/time-lpc32xx.c b/drivers/clocksource/time-lpc32xx.c
index daae61e8c820..9649cfdb9213 100644
--- a/drivers/clocksource/time-lpc32xx.c
+++ b/drivers/clocksource/time-lpc32xx.c
@@ -288,16 +288,16 @@ err_clk_enable:
 * This function asserts that we have exactly one clocksource and one
 * clock_event_device in the end.
 */
-static void __init lpc32xx_timer_init(struct device_node *np)
+static int __init lpc32xx_timer_init(struct device_node *np)
 {
        static int has_clocksource, has_clockevent;
-        int ret;
+        int ret = 0;
        if (!has_clocksource) {
                ret = lpc32xx_clocksource_init(np);
                if (!ret) {
                        has_clocksource = 1;
-                        return;
+                        return 0;
                }
        }
@@ -305,8 +305,10 @@ static void __init lpc32xx_timer_init(struct device_node *np)
                ret = lpc32xx_clockevent_init(np);
                if (!ret) {
                        has_clockevent = 1;
-                        return;
+                        return 0;
                }
        }
+        return ret;
 }
 CLOCKSOURCE_OF_DECLARE(lpc32xx_timer, "nxp,lpc3220-timer", lpc32xx_timer_init);
diff --git a/drivers/clocksource/time-orion.c b/drivers/clocksource/time-orion.c
index 0ece7427b497..a28f496e97cf 100644
--- a/drivers/clocksource/time-orion.c
+++ b/drivers/clocksource/time-orion.c
@@ -104,25 +104,36 @@ static struct irqaction orion_clkevt_irq = {
        .handler        = orion_clkevt_irq_handler,
 };
-static void __init orion_timer_init(struct device_node *np)
+static int __init orion_timer_init(struct device_node *np)
 {
        struct clk *clk;
-        int irq;
+        int irq, ret;
        /* timer registers are shared with watchdog timer */
        timer_base = of_iomap(np, 0);
-        if (!timer_base)
+        if (!timer_base) {
-                panic("%s: unable to map resource\n", np->name);
+                pr_err("%s: unable to map resource\n", np->name);
+                return -ENXIO;
+        }
        clk = of_clk_get(np, 0);
-        if (IS_ERR(clk))
+        if (IS_ERR(clk)) {
-                panic("%s: unable to get clk\n", np->name);
+                pr_err("%s: unable to get clk\n", np->name);
-        clk_prepare_enable(clk);
+                return PTR_ERR(clk);
+        }
+        ret = clk_prepare_enable(clk);
+        if (ret) {
+                pr_err("Failed to prepare clock");
+                return ret;
+        }
        /* we are only interested in timer1 irq */
        irq = irq_of_parse_and_map(np, 1);
-        if (irq <= 0)
+        if (irq <= 0) {
-                panic("%s: unable to parse timer1 irq\n", np->name);
+                pr_err("%s: unable to parse timer1 irq\n", np->name);
+                return -EINVAL;
+        }
        /* setup timer0 as free-running clocksource */
        writel(~0, timer_base + TIMER0_VAL);
@@ -130,19 +141,30 @@ static void __init orion_timer_init(struct device_node *np)
        atomic_io_modify(timer_base + TIMER_CTRL,
                TIMER0_RELOAD_EN | TIMER0_EN,
                TIMER0_RELOAD_EN | TIMER0_EN);
-        clocksource_mmio_init(timer_base + TIMER0_VAL, "orion_clocksource",
-                              clk_get_rate(clk), 300, 32,
+        ret = clocksource_mmio_init(timer_base + TIMER0_VAL, "orion_clocksource",
-                              clocksource_mmio_readl_down);
+                                    clk_get_rate(clk), 300, 32,
+                                    clocksource_mmio_readl_down);
+        if (ret) {
+                pr_err("Failed to initialize mmio timer");
+                return ret;
+        }
        sched_clock_register(orion_read_sched_clock, 32, clk_get_rate(clk));
        /* setup timer1 as clockevent timer */
-        if (setup_irq(irq, &orion_clkevt_irq))
+        ret = setup_irq(irq, &orion_clkevt_irq);
-                panic("%s: unable to setup irq\n", np->name);
+        if (ret) {
+                pr_err("%s: unable to setup irq\n", np->name);
+                return ret;
+        }
        ticks_per_jiffy = (clk_get_rate(clk) + HZ/2) / HZ;
        orion_clkevt.cpumask = cpumask_of(0);
        orion_clkevt.irq = irq;
        clockevents_config_and_register(&orion_clkevt, clk_get_rate(clk),
                                        ORION_ONESHOT_MIN, ORION_ONESHOT_MAX);
+        return 0;
 }
 CLOCKSOURCE_OF_DECLARE(orion_timer, "marvell,orion-timer", orion_timer_init);
diff --git a/drivers/clocksource/time-pistachio.c b/drivers/clocksource/time-pistachio.c
index 376e59bc5fa0..a7d9a08e4b0e 100644
--- a/drivers/clocksource/time-pistachio.c
+++ b/drivers/clocksource/time-pistachio.c
@@ -148,7 +148,7 @@ static struct pistachio_clocksource pcs_gpt = {
                },
 };
-static void __init pistachio_clksrc_of_init(struct device_node *node)
+static int __init pistachio_clksrc_of_init(struct device_node *node)
 {
        struct clk *sys_clk, *fast_clk;
        struct regmap *periph_regs;
@@ -158,45 +158,45 @@ static void __init pistachio_clksrc_of_init(struct device_node *node)
        pcs_gpt.base = of_iomap(node, 0);
        if (!pcs_gpt.base) {
                pr_err("cannot iomap\n");
-                return;
+                return -ENXIO;
        }
        periph_regs = syscon_regmap_lookup_by_phandle(node, "img,cr-periph");
        if (IS_ERR(periph_regs)) {
                pr_err("cannot get peripheral regmap (%ld)\n",
                       PTR_ERR(periph_regs));
-                return;
+                return PTR_ERR(periph_regs);
        }
        /* Switch to using the fast counter clock */
        ret = regmap_update_bits(periph_regs, PERIP_TIMER_CONTROL,
                                 0xf, 0x0);
        if (ret)
-                return;
+                return ret;
        sys_clk = of_clk_get_by_name(node, "sys");
        if (IS_ERR(sys_clk)) {
                pr_err("clock get failed (%ld)\n", PTR_ERR(sys_clk));
-                return;
+                return PTR_ERR(sys_clk);
        }
        fast_clk = of_clk_get_by_name(node, "fast");
        if (IS_ERR(fast_clk)) {
                pr_err("clock get failed (%lu)\n", PTR_ERR(fast_clk));
-                return;
+                return PTR_ERR(fast_clk);
        }
        ret = clk_prepare_enable(sys_clk);
        if (ret < 0) {
                pr_err("failed to enable clock (%d)\n", ret);
-                return;
+                return ret;
        }
        ret = clk_prepare_enable(fast_clk);
        if (ret < 0) {
                pr_err("failed to enable clock (%d)\n", ret);
                clk_disable_unprepare(sys_clk);
-                return;
+                return ret;
        }
        rate = clk_get_rate(fast_clk);
@@ -212,7 +212,7 @@ static void __init pistachio_clksrc_of_init(struct device_node *node)
        raw_spin_lock_init(&pcs_gpt.lock);
        sched_clock_register(pistachio_read_sched_clock, 32, rate);
-        clocksource_register_hz(&pcs_gpt.cs, rate);
+        return clocksource_register_hz(&pcs_gpt.cs, rate);
 }
 CLOCKSOURCE_OF_DECLARE(pistachio_gptimer, "img,pistachio-gptimer",
                       pistachio_clksrc_of_init);
diff --git a/drivers/clocksource/timer-atlas7.c b/drivers/clocksource/timer-atlas7.c
index 27fa13680be1..90f8fbc154a4 100644
--- a/drivers/clocksource/timer-atlas7.c
+++ b/drivers/clocksource/timer-atlas7.c
@@ -238,7 +238,7 @@ static struct notifier_block sirfsoc_cpu_nb = {
        .notifier_call = sirfsoc_cpu_notify,
 };
-static void __init sirfsoc_clockevent_init(void)
+static int __init sirfsoc_clockevent_init(void)
 {
        sirfsoc_clockevent = alloc_percpu(struct clock_event_device);
        BUG_ON(!sirfsoc_clockevent);
@@ -246,11 +246,11 @@ static void __init sirfsoc_clockevent_init(void)
        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));
+        return sirfsoc_local_timer_setup(this_cpu_ptr(sirfsoc_clockevent));
 }
 /* initialize the kernel jiffy timer source */
-static void __init sirfsoc_atlas7_timer_init(struct device_node *np)
+static int __init sirfsoc_atlas7_timer_init(struct device_node *np)
 {
        struct clk *clk;
@@ -279,23 +279,29 @@ static void __init sirfsoc_atlas7_timer_init(struct device_node *np)
        BUG_ON(clocksource_register_hz(&sirfsoc_clocksource, atlas7_timer_rate));
-        sirfsoc_clockevent_init();
+        return sirfsoc_clockevent_init();
 }
-static void __init sirfsoc_of_timer_init(struct device_node *np)
+static int __init sirfsoc_of_timer_init(struct device_node *np)
 {
        sirfsoc_timer_base = of_iomap(np, 0);
-        if (!sirfsoc_timer_base)
+        if (!sirfsoc_timer_base) {
-                panic("unable to map timer cpu registers\n");
+                pr_err("unable to map timer cpu registers\n");
+                return -ENXIO;
+        }
        sirfsoc_timer_irq.irq = irq_of_parse_and_map(np, 0);
-        if (!sirfsoc_timer_irq.irq)
+        if (!sirfsoc_timer_irq.irq) {
-                panic("No irq passed for timer0 via DT\n");
+                pr_err("No irq passed for timer0 via DT\n");
+                return -EINVAL;
+        }
        sirfsoc_timer1_irq.irq = irq_of_parse_and_map(np, 1);
-        if (!sirfsoc_timer1_irq.irq)
+        if (!sirfsoc_timer1_irq.irq) {
-                panic("No irq passed for timer1 via DT\n");
+                pr_err("No irq passed for timer1 via DT\n");
+                return -EINVAL;
+        }
-        sirfsoc_atlas7_timer_init(np);
+        return sirfsoc_atlas7_timer_init(np);
 }
 CLOCKSOURCE_OF_DECLARE(sirfsoc_atlas7_timer, "sirf,atlas7-tick", sirfsoc_of_timer_init);
diff --git a/drivers/clocksource/timer-atmel-pit.c b/drivers/clocksource/timer-atmel-pit.c
index d911c5dca8f1..1ffac0cb0cb7 100644
--- a/drivers/clocksource/timer-atmel-pit.c
+++ b/drivers/clocksource/timer-atmel-pit.c
@@ -177,7 +177,7 @@ static irqreturn_t at91sam926x_pit_interrupt(int irq, void *dev_id)
 /*
 * Set up both clocksource and clockevent support.
 */
-static void __init at91sam926x_pit_common_init(struct pit_data *data)
+static int __init at91sam926x_pit_common_init(struct pit_data *data)
 {
        unsigned long   pit_rate;
        unsigned        bits;
@@ -204,14 +204,21 @@ static void __init at91sam926x_pit_common_init(struct pit_data *data)
        data->clksrc.rating = 175;
        data->clksrc.read = read_pit_clk;
        data->clksrc.flags = CLOCK_SOURCE_IS_CONTINUOUS;
-        clocksource_register_hz(&data->clksrc, pit_rate);
+        
+        ret = clocksource_register_hz(&data->clksrc, pit_rate);
+        if (ret) {
+                pr_err("Failed to register clocksource");
+                return ret;
+        }
        /* Set up irq handler */
        ret = request_irq(data->irq, at91sam926x_pit_interrupt,
                          IRQF_SHARED | IRQF_TIMER | IRQF_IRQPOLL,
                          "at91_tick", data);
-        if (ret)
+        if (ret) {
-                panic(pr_fmt("Unable to setup IRQ\n"));
+                pr_err("Unable to setup IRQ\n");
+                return ret;
+        }
        /* Set up and register clockevents */
        data->clkevt.name = "pit";
@@ -226,34 +233,42 @@ static void __init at91sam926x_pit_common_init(struct pit_data *data)
        data->clkevt.resume = at91sam926x_pit_resume;
        data->clkevt.suspend = at91sam926x_pit_suspend;
        clockevents_register_device(&data->clkevt);
+        return 0;
 }
-static void __init at91sam926x_pit_dt_init(struct device_node *node)
+static int __init at91sam926x_pit_dt_init(struct device_node *node)
 {
        struct pit_data *data;
        data = kzalloc(sizeof(*data), GFP_KERNEL);
        if (!data)
-                panic(pr_fmt("Unable to allocate memory\n"));
+                return -ENOMEM;
        data->base = of_iomap(node, 0);
-        if (!data->base)
+        if (!data->base) {
-                panic(pr_fmt("Could not map PIT address\n"));
+                pr_err("Could not map PIT address\n");
+                return -ENXIO;
+        }
        data->mck = of_clk_get(node, 0);
        if (IS_ERR(data->mck))
                /* Fallback on clkdev for !CCF-based boards */
                data->mck = clk_get(NULL, "mck");
-        if (IS_ERR(data->mck))
+        if (IS_ERR(data->mck)) {
-                panic(pr_fmt("Unable to get mck clk\n"));
+                pr_err("Unable to get mck clk\n");
+                return PTR_ERR(data->mck);
+        }
        /* Get the interrupts property */
        data->irq = irq_of_parse_and_map(node, 0);
-        if (!data->irq)
+        if (!data->irq) {
-                panic(pr_fmt("Unable to get IRQ from DT\n"));
+                pr_err("Unable to get IRQ from DT\n");
+                return -EINVAL;
+        }
-        at91sam926x_pit_common_init(data);
+        return at91sam926x_pit_common_init(data);
 }
 CLOCKSOURCE_OF_DECLARE(at91sam926x_pit, "atmel,at91sam9260-pit",
                       at91sam926x_pit_dt_init);
diff --git a/drivers/clocksource/timer-atmel-st.c b/drivers/clocksource/timer-atmel-st.c
index 29d21d68df5a..e90ab5b63a90 100644
--- a/drivers/clocksource/timer-atmel-st.c
+++ b/drivers/clocksource/timer-atmel-st.c
@@ -194,15 +194,17 @@ static struct clock_event_device clkevt = {
 /*
 * ST (system timer) module supports both clockevents and clocksource.
 */
-static void __init atmel_st_timer_init(struct device_node *node)
+static int __init atmel_st_timer_init(struct device_node *node)
 {
        struct clk *sclk;
        unsigned int sclk_rate, val;
        int irq, ret;
        regmap_st = syscon_node_to_regmap(node);
-        if (IS_ERR(regmap_st))
+        if (IS_ERR(regmap_st)) {
-                panic(pr_fmt("Unable to get regmap\n"));
+                pr_err("Unable to get regmap\n");
+                return PTR_ERR(regmap_st);
+        }
        /* Disable all timer interrupts, and clear any pending ones */
        regmap_write(regmap_st, AT91_ST_IDR,
@@ -211,27 +213,37 @@ static void __init atmel_st_timer_init(struct device_node *node)
        /* Get the interrupts property */
        irq  = irq_of_parse_and_map(node, 0);
-        if (!irq)
+        if (!irq) {
-                panic(pr_fmt("Unable to get IRQ from DT\n"));
+                pr_err("Unable to get IRQ from DT\n");
+                return -EINVAL;
+        }
        /* Make IRQs happen for the system timer */
        ret = request_irq(irq, at91rm9200_timer_interrupt,
                          IRQF_SHARED | IRQF_TIMER | IRQF_IRQPOLL,
                          "at91_tick", regmap_st);
-        if (ret)
+        if (ret) {
-                panic(pr_fmt("Unable to setup IRQ\n"));
+                pr_err("Unable to setup IRQ\n");
+                return ret;
+        }
        sclk = of_clk_get(node, 0);
-        if (IS_ERR(sclk))
+        if (IS_ERR(sclk)) {
-                panic(pr_fmt("Unable to get slow clock\n"));
+                pr_err("Unable to get slow clock\n");
+                return PTR_ERR(sclk);
+        }
-        clk_prepare_enable(sclk);
+        ret = clk_prepare_enable(sclk);
-        if (ret)
+        if (ret) {
-                panic(pr_fmt("Could not enable slow clock\n"));
+                pr_err("Could not enable slow clock\n");
+                return ret;
+        }
        sclk_rate = clk_get_rate(sclk);
-        if (!sclk_rate)
+        if (!sclk_rate) {
-                panic(pr_fmt("Invalid slow clock rate\n"));
+                pr_err("Invalid slow clock rate\n");
+                return -EINVAL;
+        }
        timer_latch = (sclk_rate + HZ / 2) / HZ;
        /* The 32KiHz "Slow Clock" (tick every 30517.58 nanoseconds) is used
@@ -246,7 +258,7 @@ static void __init atmel_st_timer_init(struct device_node *node)
                                        2, AT91_ST_ALMV);
        /* register clocksource */
-        clocksource_register_hz(&clk32k, sclk_rate);
+        return clocksource_register_hz(&clk32k, sclk_rate);
 }
 CLOCKSOURCE_OF_DECLARE(atmel_st_timer, "atmel,at91rm9200-st",
                       atmel_st_timer_init);
diff --git a/drivers/clocksource/timer-digicolor.c b/drivers/clocksource/timer-digicolor.c
index a536eeb634d8..10318cc99c0e 100644
--- a/drivers/clocksource/timer-digicolor.c
+++ b/drivers/clocksource/timer-digicolor.c
@@ -63,7 +63,7 @@ struct digicolor_timer {
        int timer_id; /* one of TIMER_* */
 };
-struct digicolor_timer *dc_timer(struct clock_event_device *ce)
+static struct digicolor_timer *dc_timer(struct clock_event_device *ce)
 {
        return container_of(ce, struct digicolor_timer, ce);
 }
@@ -148,7 +148,7 @@ static u64 notrace digicolor_timer_sched_read(void)
        return ~readl(dc_timer_dev.base + COUNT(TIMER_B));
 }
-static void __init digicolor_timer_init(struct device_node *node)
+static int __init digicolor_timer_init(struct device_node *node)
 {
        unsigned long rate;
        struct clk *clk;
@@ -161,19 +161,19 @@ static void __init digicolor_timer_init(struct device_node *node)
        dc_timer_dev.base = of_iomap(node, 0);
        if (!dc_timer_dev.base) {
                pr_err("Can't map registers");
-                return;
+                return -ENXIO;
        }
        irq = irq_of_parse_and_map(node, dc_timer_dev.timer_id);
        if (irq <= 0) {
                pr_err("Can't parse IRQ");
-                return;
+                return -EINVAL;
        }
        clk = of_clk_get(node, 0);
        if (IS_ERR(clk)) {
                pr_err("Can't get timer clock");
-                return;
+                return PTR_ERR(clk);
        }
        clk_prepare_enable(clk);
        rate = clk_get_rate(clk);
@@ -190,13 +190,17 @@ static void __init digicolor_timer_init(struct device_node *node)
        ret = request_irq(irq, digicolor_timer_interrupt,
                          IRQF_TIMER | IRQF_IRQPOLL, "digicolor_timerC",
                          &dc_timer_dev.ce);
-        if (ret)
+        if (ret) {
                pr_warn("request of timer irq %d failed (%d)\n", irq, ret);
+                return ret;
+        }
        dc_timer_dev.ce.cpumask = cpu_possible_mask;
        dc_timer_dev.ce.irq = irq;
        clockevents_config_and_register(&dc_timer_dev.ce, rate, 0, 0xffffffff);
+        return 0;
 }
 CLOCKSOURCE_OF_DECLARE(conexant_digicolor, "cnxt,cx92755-timer",
                       digicolor_timer_init);
diff --git a/drivers/clocksource/timer-imx-gpt.c b/drivers/clocksource/timer-imx-gpt.c
index 99ec96769dda..f595460bfc58 100644
--- a/drivers/clocksource/timer-imx-gpt.c
+++ b/drivers/clocksource/timer-imx-gpt.c
@@ -407,8 +407,10 @@ static const struct imx_gpt_data imx6dl_gpt_data = {
        .set_next_event = v2_set_next_event,
 };
-static void __init _mxc_timer_init(struct imx_timer *imxtm)
+static int __init _mxc_timer_init(struct imx_timer *imxtm)
 {
+        int ret;
        switch (imxtm->type) {
        case GPT_TYPE_IMX1:
                imxtm->gpt = &imx1_gpt_data;
@@ -423,12 +425,12 @@ static void __init _mxc_timer_init(struct imx_timer *imxtm)
                imxtm->gpt = &imx6dl_gpt_data;
                break;
        default:
-                BUG();
+                return -EINVAL;
        }
        if (IS_ERR(imxtm->clk_per)) {
                pr_err("i.MX timer: unable to get clk\n");
-                return;
+                return PTR_ERR(imxtm->clk_per);
        }
        if (!IS_ERR(imxtm->clk_ipg))
@@ -446,8 +448,11 @@ static void __init _mxc_timer_init(struct imx_timer *imxtm)
        imxtm->gpt->gpt_setup_tctl(imxtm);
        /* init and register the timer to the framework */
-        mxc_clocksource_init(imxtm);
+        ret = mxc_clocksource_init(imxtm);
-        mxc_clockevent_init(imxtm);
+        if (ret)
+                return ret;
+        return mxc_clockevent_init(imxtm);
 }
 void __init mxc_timer_init(unsigned long pbase, int irq, enum imx_gpt_type type)
@@ -469,21 +474,27 @@ void __init mxc_timer_init(unsigned long pbase, int irq, enum imx_gpt_type type)
        _mxc_timer_init(imxtm);
 }
-static void __init mxc_timer_init_dt(struct device_node *np,  enum imx_gpt_type type)
+static int __init mxc_timer_init_dt(struct device_node *np,  enum imx_gpt_type type)
 {
        struct imx_timer *imxtm;
        static int initialized;
+        int ret;
        /* Support one instance only */
        if (initialized)
-                return;
+                return 0;
        imxtm = kzalloc(sizeof(*imxtm), GFP_KERNEL);
-        BUG_ON(!imxtm);
+        if (!imxtm)
+                return -ENOMEM;
        imxtm->base = of_iomap(np, 0);
-        WARN_ON(!imxtm->base);
+        if (!imxtm->base)
+                return -ENXIO;
        imxtm->irq = irq_of_parse_and_map(np, 0);
+        if (imxtm->irq <= 0)
+                return -EINVAL;
        imxtm->clk_ipg = of_clk_get_by_name(np, "ipg");
@@ -494,22 +505,26 @@ static void __init mxc_timer_init_dt(struct device_node *np,  enum imx_gpt_type
        imxtm->type = type;
-        _mxc_timer_init(imxtm);
+        ret = _mxc_timer_init(imxtm);
+        if (ret)
+                return ret;
        initialized = 1;
+        return 0;
 }
-static void __init imx1_timer_init_dt(struct device_node *np)
+static int __init imx1_timer_init_dt(struct device_node *np)
 {
-        mxc_timer_init_dt(np, GPT_TYPE_IMX1);
+        return mxc_timer_init_dt(np, GPT_TYPE_IMX1);
 }
-static void __init imx21_timer_init_dt(struct device_node *np)
+static int __init imx21_timer_init_dt(struct device_node *np)
 {
-        mxc_timer_init_dt(np, GPT_TYPE_IMX21);
+        return mxc_timer_init_dt(np, GPT_TYPE_IMX21);
 }
-static void __init imx31_timer_init_dt(struct device_node *np)
+static int __init imx31_timer_init_dt(struct device_node *np)
 {
        enum imx_gpt_type type = GPT_TYPE_IMX31;
@@ -522,12 +537,12 @@ static void __init imx31_timer_init_dt(struct device_node *np)
        if (of_machine_is_compatible("fsl,imx6dl"))
                type = GPT_TYPE_IMX6DL;
-        mxc_timer_init_dt(np, type);
+        return mxc_timer_init_dt(np, type);
 }
-static void __init imx6dl_timer_init_dt(struct device_node *np)
+static int __init imx6dl_timer_init_dt(struct device_node *np)
 {
-        mxc_timer_init_dt(np, GPT_TYPE_IMX6DL);
+        return mxc_timer_init_dt(np, GPT_TYPE_IMX6DL);
 }
 CLOCKSOURCE_OF_DECLARE(imx1_timer, "fsl,imx1-gpt", imx1_timer_init_dt);
diff --git a/drivers/clocksource/timer-integrator-ap.c b/drivers/clocksource/timer-integrator-ap.c
index 3f59ac2180dc..df6e672afc04 100644
--- a/drivers/clocksource/timer-integrator-ap.c
+++ b/drivers/clocksource/timer-integrator-ap.c
@@ -36,11 +36,12 @@ static u64 notrace integrator_read_sched_clock(void)
        return -readl(sched_clk_base + TIMER_VALUE);
 }
-static void integrator_clocksource_init(unsigned long inrate,
+static int integrator_clocksource_init(unsigned long inrate,
-                                        void __iomem *base)
+                                       void __iomem *base)
 {
        u32 ctrl = TIMER_CTRL_ENABLE | TIMER_CTRL_PERIODIC;
        unsigned long rate = inrate;
+        int ret;
        if (rate >= 1500000) {
                rate /= 16;
@@ -50,11 +51,15 @@ static void integrator_clocksource_init(unsigned long inrate,
        writel(0xffff, base + TIMER_LOAD);
        writel(ctrl, base + TIMER_CTRL);
-        clocksource_mmio_init(base + TIMER_VALUE, "timer2",
+        ret = clocksource_mmio_init(base + TIMER_VALUE, "timer2",
-                        rate, 200, 16, clocksource_mmio_readl_down);
+                                    rate, 200, 16, clocksource_mmio_readl_down);
+        if (ret)
+                return ret;
        sched_clk_base = base;
        sched_clock_register(integrator_read_sched_clock, 16, rate);
+        return 0;
 }
 static unsigned long timer_reload;
@@ -138,11 +143,12 @@ static struct irqaction integrator_timer_irq = {
        .dev_id         = &integrator_clockevent,
 };
-static void integrator_clockevent_init(unsigned long inrate,
+static int integrator_clockevent_init(unsigned long inrate,
-                                void __iomem *base, int irq)
+                                      void __iomem *base, int irq)
 {
        unsigned long rate = inrate;
        unsigned int ctrl = 0;
+        int ret;
        clkevt_base = base;
        /* Calculate and program a divisor */
@@ -156,14 +162,18 @@ static void integrator_clockevent_init(unsigned long inrate,
        timer_reload = rate / HZ;
        writel(ctrl, clkevt_base + TIMER_CTRL);
-        setup_irq(irq, &integrator_timer_irq);
+        ret = setup_irq(irq, &integrator_timer_irq);
+        if (ret)
+                return ret;
        clockevents_config_and_register(&integrator_clockevent,
                                        rate,
                                        1,
                                        0xffffU);
+        return 0;
 }
-static void __init integrator_ap_timer_init_of(struct device_node *node)
+static int __init integrator_ap_timer_init_of(struct device_node *node)
 {
        const char *path;
        void __iomem *base;
@@ -176,12 +186,12 @@ static void __init integrator_ap_timer_init_of(struct device_node *node)
        base = of_io_request_and_map(node, 0, "integrator-timer");
        if (IS_ERR(base))
-                return;
+                return PTR_ERR(base);
        clk = of_clk_get(node, 0);
        if (IS_ERR(clk)) {
                pr_err("No clock for %s\n", node->name);
-                return;
+                return PTR_ERR(clk);
        }
        clk_prepare_enable(clk);
        rate = clk_get_rate(clk);
@@ -189,30 +199,37 @@ static void __init integrator_ap_timer_init_of(struct device_node *node)
        err = of_property_read_string(of_aliases,
                                "arm,timer-primary", &path);
-        if (WARN_ON(err))
+        if (err) {
-                return;
+                pr_warn("Failed to read property");
+                return err;
+        }
        pri_node = of_find_node_by_path(path);
        err = of_property_read_string(of_aliases,
                                "arm,timer-secondary", &path);
-        if (WARN_ON(err))
+        if (err) {
-                return;
+                pr_warn("Failed to read property");             
+                return err;
+        }
        sec_node = of_find_node_by_path(path);
-        if (node == pri_node) {
+        if (node == pri_node)
                /* The primary timer lacks IRQ, use as clocksource */
-                integrator_clocksource_init(rate, base);
+                return integrator_clocksource_init(rate, base);
-                return;
-        }
        if (node == sec_node) {
                /* The secondary timer will drive the clock event */
                irq = irq_of_parse_and_map(node, 0);
-                integrator_clockevent_init(rate, base, irq);
+                return integrator_clockevent_init(rate, base, irq);
-                return;
        }
        pr_info("Timer @%p unused\n", base);
        clk_disable_unprepare(clk);
+        return 0;
 }
 CLOCKSOURCE_OF_DECLARE(integrator_ap_timer, "arm,integrator-timer",
diff --git a/drivers/clocksource/timer-keystone.c b/drivers/clocksource/timer-keystone.c
index 1cea08cf603e..ab68a47ab3b4 100644
--- a/drivers/clocksource/timer-keystone.c
+++ b/drivers/clocksource/timer-keystone.c
@@ -144,7 +144,7 @@ static int keystone_set_periodic(struct clock_event_device *evt)
        return 0;
 }
-static void __init keystone_timer_init(struct device_node *np)
+static int __init keystone_timer_init(struct device_node *np)
 {
        struct clock_event_device *event_dev = &timer.event_dev;
        unsigned long rate;
@@ -154,20 +154,20 @@ static void __init keystone_timer_init(struct device_node *np)
        irq  = irq_of_parse_and_map(np, 0);
        if (!irq) {
                pr_err("%s: failed to map interrupts\n", __func__);
-                return;
+                return -EINVAL;
        }
        timer.base = of_iomap(np, 0);
        if (!timer.base) {
                pr_err("%s: failed to map registers\n", __func__);
-                return;
+                return -ENXIO;
        }
        clk = of_clk_get(np, 0);
        if (IS_ERR(clk)) {
                pr_err("%s: failed to get clock\n", __func__);
                iounmap(timer.base);
-                return;
+                return PTR_ERR(clk);
        }
        error = clk_prepare_enable(clk);
@@ -219,11 +219,12 @@ static void __init keystone_timer_init(struct device_node *np)
        clockevents_config_and_register(event_dev, rate, 1, ULONG_MAX);
        pr_info("keystone timer clock @%lu Hz\n", rate);
-        return;
+        return 0;
 err:
        clk_put(clk);
        iounmap(timer.base);
+        return error;
 }
 CLOCKSOURCE_OF_DECLARE(keystone_timer, "ti,keystone-timer",
-                                        keystone_timer_init);
+                           keystone_timer_init);
diff --git a/drivers/clocksource/timer-nps.c b/drivers/clocksource/timer-nps.c
index d46108920b2c..70c149af8ee0 100644
--- a/drivers/clocksource/timer-nps.c
+++ b/drivers/clocksource/timer-nps.c
@@ -55,8 +55,8 @@ static cycle_t nps_clksrc_read(struct clocksource *clksrc)
        return (cycle_t)ioread32be(nps_msu_reg_low_addr[cluster]);
 }
-static void __init nps_setup_clocksource(struct device_node *node,
+static int __init nps_setup_clocksource(struct device_node *node,
-                                         struct clk *clk)
+                                        struct clk *clk)
 {
        int ret, cluster;
@@ -68,7 +68,7 @@ static void __init nps_setup_clocksource(struct device_node *node,
        ret = clk_prepare_enable(clk);
        if (ret) {
                pr_err("Couldn't enable parent clock\n");
-                return;
+                return ret;
        }
        nps_timer_rate = clk_get_rate(clk);
@@ -79,19 +79,21 @@ static void __init nps_setup_clocksource(struct device_node *node,
                pr_err("Couldn't register clock source.\n");
                clk_disable_unprepare(clk);
        }
+        return ret;
 }
-static void __init nps_timer_init(struct device_node *node)
+static int __init nps_timer_init(struct device_node *node)
 {
        struct clk *clk;
        clk = of_clk_get(node, 0);
        if (IS_ERR(clk)) {
                pr_err("Can't get timer clock.\n");
-                return;
+                return PTR_ERR(clk);
        }
-        nps_setup_clocksource(node, clk);
+        return nps_setup_clocksource(node, clk);
 }
 CLOCKSOURCE_OF_DECLARE(ezchip_nps400_clksrc, "ezchip,nps400-timer",
diff --git a/drivers/clocksource/timer-oxnas-rps.c b/drivers/clocksource/timer-oxnas-rps.c
new file mode 100644
index 000000000000..bd887e2a8cf8
--- /dev/null
+++ b/drivers/clocksource/timer-oxnas-rps.c
@@ -0,0 +1,297 @@
+/*
+ * drivers/clocksource/timer-oxnas-rps.c
+ *
+ * Copyright (C) 2009 Oxford Semiconductor Ltd
+ * Copyright (C) 2013 Ma Haijun <mahaijuns@gmail.com>
+ * Copyright (C) 2016 Neil Armstrong <narmstrong@baylibre.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#define pr_fmt(fmt)     KBUILD_MODNAME ": " fmt
+#include <linux/init.h>
+#include <linux/irq.h>
+#include <linux/io.h>
+#include <linux/clk.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/of_irq.h>
+#include <linux/of_address.h>
+#include <linux/clockchips.h>
+#include <linux/sched_clock.h>
+/* TIMER1 used as tick
+ * TIMER2 used as clocksource
+ */
+/* Registers definitions */
+#define TIMER_LOAD_REG          0x0
+#define TIMER_CURR_REG          0x4
+#define TIMER_CTRL_REG          0x8
+#define TIMER_CLRINT_REG        0xC
+#define TIMER_BITS              24
+#define TIMER_MAX_VAL           (BIT(TIMER_BITS) - 1)
+#define TIMER_PERIODIC          BIT(6)
+#define TIMER_ENABLE            BIT(7)
+#define TIMER_DIV1              (0)
+#define TIMER_DIV16             (1 << 2)
+#define TIMER_DIV256            (2 << 2)
+#define TIMER1_REG_OFFSET       0
+#define TIMER2_REG_OFFSET       0x20
+/* Clockevent & Clocksource data */
+struct oxnas_rps_timer {
+        struct clock_event_device clkevent;
+        void __iomem *clksrc_base;
+        void __iomem *clkevt_base;
+        unsigned long timer_period;
+        unsigned int timer_prescaler;
+        struct clk *clk;
+        int irq;
+};
+static irqreturn_t oxnas_rps_timer_irq(int irq, void *dev_id)
+{
+        struct oxnas_rps_timer *rps = dev_id;
+        writel_relaxed(0, rps->clkevt_base + TIMER_CLRINT_REG);
+        rps->clkevent.event_handler(&rps->clkevent);
+        return IRQ_HANDLED;
+}
+static void oxnas_rps_timer_config(struct oxnas_rps_timer *rps,
+                                   unsigned long period,
+                                   unsigned int periodic)
+{
+        uint32_t cfg = rps->timer_prescaler;
+        if (period)
+                cfg |= TIMER_ENABLE;
+        if (periodic)
+                cfg |= TIMER_PERIODIC;
+        writel_relaxed(period, rps->clkevt_base + TIMER_LOAD_REG);
+        writel_relaxed(cfg, rps->clkevt_base + TIMER_CTRL_REG);
+}
+static int oxnas_rps_timer_shutdown(struct clock_event_device *evt)
+{
+        struct oxnas_rps_timer *rps =
+                container_of(evt, struct oxnas_rps_timer, clkevent);
+        oxnas_rps_timer_config(rps, 0, 0);
+        return 0;
+}
+static int oxnas_rps_timer_set_periodic(struct clock_event_device *evt)
+{
+        struct oxnas_rps_timer *rps =
+                container_of(evt, struct oxnas_rps_timer, clkevent);
+        oxnas_rps_timer_config(rps, rps->timer_period, 1);
+        return 0;
+}
+static int oxnas_rps_timer_set_oneshot(struct clock_event_device *evt)
+{
+        struct oxnas_rps_timer *rps =
+                container_of(evt, struct oxnas_rps_timer, clkevent);
+        oxnas_rps_timer_config(rps, rps->timer_period, 0);
+        return 0;
+}
+static int oxnas_rps_timer_next_event(unsigned long delta,
+                                struct clock_event_device *evt)
+{
+        struct oxnas_rps_timer *rps =
+                container_of(evt, struct oxnas_rps_timer, clkevent);
+        oxnas_rps_timer_config(rps, delta, 0);
+        return 0;
+}
+static int __init oxnas_rps_clockevent_init(struct oxnas_rps_timer *rps)
+{
+        ulong clk_rate = clk_get_rate(rps->clk);
+        ulong timer_rate;
+        /* Start with prescaler 1 */
+        rps->timer_prescaler = TIMER_DIV1;
+        rps->timer_period = DIV_ROUND_UP(clk_rate, HZ);
+        timer_rate = clk_rate;
+        if (rps->timer_period > TIMER_MAX_VAL) {
+                rps->timer_prescaler = TIMER_DIV16;
+                timer_rate = clk_rate / 16;
+                rps->timer_period = DIV_ROUND_UP(timer_rate, HZ);
+        }
+        if (rps->timer_period > TIMER_MAX_VAL) {
+                rps->timer_prescaler = TIMER_DIV256;
+                timer_rate = clk_rate / 256;
+                rps->timer_period = DIV_ROUND_UP(timer_rate, HZ);
+        }
+        rps->clkevent.name = "oxnas-rps";
+        rps->clkevent.features = CLOCK_EVT_FEAT_PERIODIC |
+                                 CLOCK_EVT_FEAT_ONESHOT |
+                                 CLOCK_EVT_FEAT_DYNIRQ;
+        rps->clkevent.tick_resume = oxnas_rps_timer_shutdown;
+        rps->clkevent.set_state_shutdown = oxnas_rps_timer_shutdown;
+        rps->clkevent.set_state_periodic = oxnas_rps_timer_set_periodic;
+        rps->clkevent.set_state_oneshot = oxnas_rps_timer_set_oneshot;
+        rps->clkevent.set_next_event = oxnas_rps_timer_next_event;
+        rps->clkevent.rating = 200;
+        rps->clkevent.cpumask = cpu_possible_mask;
+        rps->clkevent.irq = rps->irq;
+        clockevents_config_and_register(&rps->clkevent,
+                                        timer_rate,
+                                        1,
+                                        TIMER_MAX_VAL);
+        pr_info("Registered clock event rate %luHz prescaler %x period %lu\n",
+                        clk_rate,
+                        rps->timer_prescaler,
+                        rps->timer_period);
+        return 0;
+}
+/* Clocksource */
+static void __iomem *timer_sched_base;
+static u64 notrace oxnas_rps_read_sched_clock(void)
+{
+        return ~readl_relaxed(timer_sched_base);
+}
+static int __init oxnas_rps_clocksource_init(struct oxnas_rps_timer *rps)
+{
+        ulong clk_rate = clk_get_rate(rps->clk);
+        int ret;
+        /* use prescale 16 */
+        clk_rate = clk_rate / 16;
+        writel_relaxed(TIMER_MAX_VAL, rps->clksrc_base + TIMER_LOAD_REG);
+        writel_relaxed(TIMER_PERIODIC | TIMER_ENABLE | TIMER_DIV16,
+                        rps->clksrc_base + TIMER_CTRL_REG);
+        timer_sched_base = rps->clksrc_base + TIMER_CURR_REG;
+        sched_clock_register(oxnas_rps_read_sched_clock,
+                             TIMER_BITS, clk_rate);
+        ret = clocksource_mmio_init(timer_sched_base,
+                                    "oxnas_rps_clocksource_timer",
+                                    clk_rate, 250, TIMER_BITS,
+                                    clocksource_mmio_readl_down);
+        if (WARN_ON(ret)) {
+                pr_err("can't register clocksource\n");
+                return ret;
+        }
+        pr_info("Registered clocksource rate %luHz\n", clk_rate);
+        return 0;
+}
+static int __init oxnas_rps_timer_init(struct device_node *np)
+{
+        struct oxnas_rps_timer *rps;
+        void __iomem *base;
+        int ret;
+        rps = kzalloc(sizeof(*rps), GFP_KERNEL);
+        if (!rps)
+                return -ENOMEM;
+        rps->clk = of_clk_get(np, 0);
+        if (IS_ERR(rps->clk)) {
+                ret = PTR_ERR(rps->clk);
+                goto err_alloc;
+        }
+        ret = clk_prepare_enable(rps->clk);
+        if (ret)
+                goto err_clk;
+        base = of_iomap(np, 0);
+        if (!base) {
+                ret = -ENXIO;
+                goto err_clk_prepare;
+        }
+        rps->irq = irq_of_parse_and_map(np, 0);
+        if (rps->irq < 0) {
+                ret = -EINVAL;
+                goto err_iomap;
+        }
+        rps->clkevt_base = base + TIMER1_REG_OFFSET;
+        rps->clksrc_base = base + TIMER2_REG_OFFSET;
+        /* Disable timers */
+        writel_relaxed(0, rps->clkevt_base + TIMER_CTRL_REG);
+        writel_relaxed(0, rps->clksrc_base + TIMER_CTRL_REG);
+        writel_relaxed(0, rps->clkevt_base + TIMER_LOAD_REG);
+        writel_relaxed(0, rps->clksrc_base + TIMER_LOAD_REG);
+        writel_relaxed(0, rps->clkevt_base + TIMER_CLRINT_REG);
+        writel_relaxed(0, rps->clksrc_base + TIMER_CLRINT_REG);
+        ret = request_irq(rps->irq, oxnas_rps_timer_irq,
+                          IRQF_TIMER | IRQF_IRQPOLL,
+                          "rps-timer", rps);
+        if (ret)
+                goto err_iomap;
+        ret = oxnas_rps_clocksource_init(rps);
+        if (ret)
+                goto err_irqreq;
+        ret = oxnas_rps_clockevent_init(rps);
+        if (ret)
+                goto err_irqreq;
+        return 0;
+err_irqreq:
+        free_irq(rps->irq, rps);
+err_iomap:
+        iounmap(base);
+err_clk_prepare:
+        clk_disable_unprepare(rps->clk);
+err_clk:
+        clk_put(rps->clk);
+err_alloc:
+        kfree(rps);
+        return ret;
+}
+CLOCKSOURCE_OF_DECLARE(ox810se_rps,
+                       "oxsemi,ox810se-rps-timer", oxnas_rps_timer_init);
diff --git a/drivers/clocksource/timer-prima2.c b/drivers/clocksource/timer-prima2.c
index 2854c663e8b5..c32148ec7a38 100644
--- a/drivers/clocksource/timer-prima2.c
+++ b/drivers/clocksource/timer-prima2.c
@@ -19,7 +19,6 @@
 #include <linux/of_irq.h>
 #include <linux/of_address.h>
 #include <linux/sched_clock.h>
-#include <asm/mach/time.h>
 #define PRIMA2_CLOCK_FREQ 1000000
@@ -189,24 +188,36 @@ static void __init sirfsoc_clockevent_init(void)
 }
 /* initialize the kernel jiffy timer source */
-static void __init sirfsoc_prima2_timer_init(struct device_node *np)
+static int __init sirfsoc_prima2_timer_init(struct device_node *np)
 {
        unsigned long rate;
        struct clk *clk;
+        int ret;
        clk = of_clk_get(np, 0);
-        BUG_ON(IS_ERR(clk));
+        if (IS_ERR(clk)) {
+                pr_err("Failed to get clock");
+                return PTR_ERR(clk);
+        }
-        BUG_ON(clk_prepare_enable(clk));
+        ret = clk_prepare_enable(clk);
+        if (ret) {
+                pr_err("Failed to enable clock");
+                return ret;
+        }
        rate = clk_get_rate(clk);
-        BUG_ON(rate < PRIMA2_CLOCK_FREQ);
+        if (rate < PRIMA2_CLOCK_FREQ || rate % PRIMA2_CLOCK_FREQ) {
-        BUG_ON(rate % PRIMA2_CLOCK_FREQ);
+                pr_err("Invalid clock rate");
+                return -EINVAL;
+        }
        sirfsoc_timer_base = of_iomap(np, 0);
-        if (!sirfsoc_timer_base)
+        if (!sirfsoc_timer_base) {
-                panic("unable to map timer cpu registers\n");
+                pr_err("unable to map timer cpu registers\n");
+                return -ENXIO;
+        }
        sirfsoc_timer_irq.irq = irq_of_parse_and_map(np, 0);
@@ -216,14 +227,23 @@ static void __init sirfsoc_prima2_timer_init(struct device_node *np)
        writel_relaxed(0, sirfsoc_timer_base + SIRFSOC_TIMER_COUNTER_HI);
        writel_relaxed(BIT(0), sirfsoc_timer_base + SIRFSOC_TIMER_STATUS);
-        BUG_ON(clocksource_register_hz(&sirfsoc_clocksource,
+        ret = clocksource_register_hz(&sirfsoc_clocksource, PRIMA2_CLOCK_FREQ);
-                                       PRIMA2_CLOCK_FREQ));
+        if (ret) {
+                pr_err("Failed to register clocksource");
+                return ret;
+        }
        sched_clock_register(sirfsoc_read_sched_clock, 64, PRIMA2_CLOCK_FREQ);
-        BUG_ON(setup_irq(sirfsoc_timer_irq.irq, &sirfsoc_timer_irq));
+        ret = setup_irq(sirfsoc_timer_irq.irq, &sirfsoc_timer_irq);
+        if (ret) {
+                pr_err("Failed to setup irq");
+                return ret;
+        }
        sirfsoc_clockevent_init();
+        return 0;
 }
 CLOCKSOURCE_OF_DECLARE(sirfsoc_prima2_timer,
        "sirf,prima2-tick", sirfsoc_prima2_timer_init);
diff --git a/drivers/clocksource/timer-sp804.c b/drivers/clocksource/timer-sp804.c
index 5f45b9adef60..d07863388e05 100644
--- a/drivers/clocksource/timer-sp804.c
+++ b/drivers/clocksource/timer-sp804.c
@@ -77,7 +77,7 @@ void __init sp804_timer_disable(void __iomem *base)
        writel(0, base + TIMER_CTRL);
 }
-void __init __sp804_clocksource_and_sched_clock_init(void __iomem *base,
+int  __init __sp804_clocksource_and_sched_clock_init(void __iomem *base,
                                                     const char *name,
                                                     struct clk *clk,
                                                     int use_sched_clock)
@@ -89,14 +89,13 @@ void __init __sp804_clocksource_and_sched_clock_init(void __iomem *base,
                if (IS_ERR(clk)) {
                        pr_err("sp804: clock not found: %d\n",
                               (int)PTR_ERR(clk));
-                        return;
+                        return PTR_ERR(clk);
                }
        }
        rate = sp804_get_clock_rate(clk);
        if (rate < 0)
-                return;
+                return -EINVAL;
        /* setup timer 0 as free-running clocksource */
        writel(0, base + TIMER_CTRL);
@@ -112,6 +111,8 @@ void __init __sp804_clocksource_and_sched_clock_init(void __iomem *base,
                sched_clock_base = base;
                sched_clock_register(sp804_read, 32, rate);
        }
+        return 0;
 }
@@ -186,7 +187,7 @@ static struct irqaction sp804_timer_irq = {
        .dev_id         = &sp804_clockevent,
 };
-void __init __sp804_clockevents_init(void __iomem *base, unsigned int irq, struct clk *clk, const char *name)
+int __init __sp804_clockevents_init(void __iomem *base, unsigned int irq, struct clk *clk, const char *name)
 {
        struct clock_event_device *evt = &sp804_clockevent;
        long rate;
@@ -196,12 +197,12 @@ void __init __sp804_clockevents_init(void __iomem *base, unsigned int irq, struc
        if (IS_ERR(clk)) {
                pr_err("sp804: %s clock not found: %d\n", name,
                        (int)PTR_ERR(clk));
-                return;
+                return PTR_ERR(clk);
        }
        rate = sp804_get_clock_rate(clk);
        if (rate < 0)
-                return;
+                return -EINVAL;
        clkevt_base = base;
        clkevt_reload = DIV_ROUND_CLOSEST(rate, HZ);
@@ -213,27 +214,31 @@ void __init __sp804_clockevents_init(void __iomem *base, unsigned int irq, struc
        setup_irq(irq, &sp804_timer_irq);
        clockevents_config_and_register(evt, rate, 0xf, 0xffffffff);
+        return 0;
 }
-static void __init sp804_of_init(struct device_node *np)
+static int __init sp804_of_init(struct device_node *np)
 {
        static bool initialized = false;
        void __iomem *base;
-        int irq;
+        int irq, ret = -EINVAL;
        u32 irq_num = 0;
        struct clk *clk1, *clk2;
        const char *name = of_get_property(np, "compatible", NULL);
        base = of_iomap(np, 0);
-        if (WARN_ON(!base))
+        if (!base)
-                return;
+                return -ENXIO;
        /* Ensure timers are disabled */
        writel(0, base + TIMER_CTRL);
        writel(0, base + TIMER_2_BASE + TIMER_CTRL);
-        if (initialized || !of_device_is_available(np))
+        if (initialized || !of_device_is_available(np)) {
+                ret = -EINVAL;
                goto err;
+        }
        clk1 = of_clk_get(np, 0);
        if (IS_ERR(clk1))
@@ -256,35 +261,53 @@ static void __init sp804_of_init(struct device_node *np)
        of_property_read_u32(np, "arm,sp804-has-irq", &irq_num);
        if (irq_num == 2) {
-                __sp804_clockevents_init(base + TIMER_2_BASE, irq, clk2, name);
-                __sp804_clocksource_and_sched_clock_init(base, name, clk1, 1);
+                ret = __sp804_clockevents_init(base + TIMER_2_BASE, irq, clk2, name);
+                if (ret)
+                        goto err;
+                ret = __sp804_clocksource_and_sched_clock_init(base, name, clk1, 1);
+                if (ret)
+                        goto err;
        } else {
-                __sp804_clockevents_init(base, irq, clk1 , name);
-                __sp804_clocksource_and_sched_clock_init(base + TIMER_2_BASE,
+                ret = __sp804_clockevents_init(base, irq, clk1 , name);
-                                                         name, clk2, 1);
+                if (ret)
+                        goto err;
+                ret =__sp804_clocksource_and_sched_clock_init(base + TIMER_2_BASE,
+                                                              name, clk2, 1);
+                if (ret)
+                        goto err;
        }
        initialized = true;
-        return;
+        return 0;
 err:
        iounmap(base);
+        return ret;
 }
 CLOCKSOURCE_OF_DECLARE(sp804, "arm,sp804", sp804_of_init);
-static void __init integrator_cp_of_init(struct device_node *np)
+static int __init integrator_cp_of_init(struct device_node *np)
 {
        static int init_count = 0;
        void __iomem *base;
-        int irq;
+        int irq, ret = -EINVAL;
        const char *name = of_get_property(np, "compatible", NULL);
        struct clk *clk;
        base = of_iomap(np, 0);
-        if (WARN_ON(!base))
+        if (!base) {
-                return;
+                pr_err("Failed to iomap");
+                return -ENXIO;
+        }
        clk = of_clk_get(np, 0);
-        if (WARN_ON(IS_ERR(clk)))
+        if (IS_ERR(clk)) {
-                return;
+                pr_err("Failed to get clock");
+                return PTR_ERR(clk);
+        }
        /* Ensure timer is disabled */
        writel(0, base + TIMER_CTRL);
@@ -292,19 +315,24 @@ static void __init integrator_cp_of_init(struct device_node *np)
        if (init_count == 2 || !of_device_is_available(np))
                goto err;
-        if (!init_count)
+        if (!init_count) {
-                __sp804_clocksource_and_sched_clock_init(base, name, clk, 0);
+                ret = __sp804_clocksource_and_sched_clock_init(base, name, clk, 0);
-        else {
+                if (ret)
+                        goto err;
+        } else {
                irq = irq_of_parse_and_map(np, 0);
                if (irq <= 0)
                        goto err;
-                __sp804_clockevents_init(base, irq, clk, name);
+                ret = __sp804_clockevents_init(base, irq, clk, name);
+                if (ret)
+                        goto err;
        }
        init_count++;
-        return;
+        return 0;
 err:
        iounmap(base);
+        return ret;
 }
 CLOCKSOURCE_OF_DECLARE(intcp, "arm,integrator-cp-timer", integrator_cp_of_init);
diff --git a/drivers/clocksource/timer-stm32.c b/drivers/clocksource/timer-stm32.c
index f3dcb76799b4..1b2574c4fb97 100644
--- a/drivers/clocksource/timer-stm32.c
+++ b/drivers/clocksource/timer-stm32.c
@@ -98,7 +98,7 @@ static struct stm32_clock_event_ddata clock_event_ddata = {
        },
 };
-static void __init stm32_clockevent_init(struct device_node *np)
+static int __init stm32_clockevent_init(struct device_node *np)
 {
        struct stm32_clock_event_ddata *data = &clock_event_ddata;
        struct clk *clk;
@@ -130,12 +130,14 @@ static void __init stm32_clockevent_init(struct device_node *np)
        data->base = of_iomap(np, 0);
        if (!data->base) {
+                ret = -ENXIO;
                pr_err("failed to map registers for clockevent\n");
                goto err_iomap;
        }
        irq = irq_of_parse_and_map(np, 0);
        if (!irq) {
+                ret = -EINVAL;
                pr_err("%s: failed to get irq.\n", np->full_name);
                goto err_get_irq;
        }
@@ -173,7 +175,7 @@ static void __init stm32_clockevent_init(struct device_node *np)
        pr_info("%s: STM32 clockevent driver initialized (%d bits)\n",
                        np->full_name, bits);
-        return;
+        return ret;
 err_get_irq:
        iounmap(data->base);
@@ -182,7 +184,7 @@ err_iomap:
 err_clk_enable:
        clk_put(clk);
 err_clk_get:
-        return;
+        return ret;
 }
 CLOCKSOURCE_OF_DECLARE(stm32, "st,stm32-timer", stm32_clockevent_init);
diff --git a/drivers/clocksource/timer-sun5i.c b/drivers/clocksource/timer-sun5i.c
index 24c83f9efd87..c184eb84101e 100644
--- a/drivers/clocksource/timer-sun5i.c
+++ b/drivers/clocksource/timer-sun5i.c
@@ -311,33 +311,42 @@ err_free:
        return ret;
 }
-static void __init sun5i_timer_init(struct device_node *node)
+static int __init sun5i_timer_init(struct device_node *node)
 {
        struct reset_control *rstc;
        void __iomem *timer_base;
        struct clk *clk;
-        int irq;
+        int irq, ret;
        timer_base = of_io_request_and_map(node, 0, of_node_full_name(node));
-        if (IS_ERR(timer_base))
+        if (IS_ERR(timer_base)) {
-                panic("Can't map registers");
+                pr_err("Can't map registers");
+                return PTR_ERR(timer_base);;
+        }
        irq = irq_of_parse_and_map(node, 0);
-        if (irq <= 0)
+        if (irq <= 0) {
-                panic("Can't parse IRQ");
+                pr_err("Can't parse IRQ");
+                return -EINVAL;
+        }
        clk = of_clk_get(node, 0);
-        if (IS_ERR(clk))
+        if (IS_ERR(clk)) {
-                panic("Can't get timer clock");
+                pr_err("Can't get timer clock");
+                return PTR_ERR(clk);
+        }
        rstc = of_reset_control_get(node, NULL);
        if (!IS_ERR(rstc))
                reset_control_deassert(rstc);
-        sun5i_setup_clocksource(node, timer_base, clk, irq);
+        ret = sun5i_setup_clocksource(node, timer_base, clk, irq);
-        sun5i_setup_clockevent(node, timer_base, clk, irq);
+        if (ret)
+                return ret;
+        return sun5i_setup_clockevent(node, timer_base, clk, irq);
 }
 CLOCKSOURCE_OF_DECLARE(sun5i_a13, "allwinner,sun5i-a13-hstimer",
-                       sun5i_timer_init);
+                           sun5i_timer_init);
 CLOCKSOURCE_OF_DECLARE(sun7i_a20, "allwinner,sun7i-a20-hstimer",
-                       sun5i_timer_init);
+                           sun5i_timer_init);
diff --git a/drivers/clocksource/timer-ti-32k.c b/drivers/clocksource/timer-ti-32k.c
index 8518d9dfba5c..92b7e390f6c8 100644
--- a/drivers/clocksource/timer-ti-32k.c
+++ b/drivers/clocksource/timer-ti-32k.c
@@ -88,14 +88,14 @@ static u64 notrace omap_32k_read_sched_clock(void)
        return ti_32k_read_cycles(&ti_32k_timer.cs);
 }
-static void __init ti_32k_timer_init(struct device_node *np)
+static int __init ti_32k_timer_init(struct device_node *np)
 {
        int ret;
        ti_32k_timer.base = of_iomap(np, 0);
        if (!ti_32k_timer.base) {
                pr_err("Can't ioremap 32k timer base\n");
-                return;
+                return -ENXIO;
        }
        ti_32k_timer.counter = ti_32k_timer.base;
@@ -116,11 +116,13 @@ static void __init ti_32k_timer_init(struct device_node *np)
        ret = clocksource_register_hz(&ti_32k_timer.cs, 32768);
        if (ret) {
                pr_err("32k_counter: can't register clocksource\n");
-                return;
+                return ret;
        }
        sched_clock_register(omap_32k_read_sched_clock, 32, 32768);
        pr_info("OMAP clocksource: 32k_counter at 32768 Hz\n");
+        return 0;
 }
 CLOCKSOURCE_OF_DECLARE(ti_32k_timer, "ti,omap-counter32k",
                ti_32k_timer_init);
diff --git a/drivers/clocksource/timer-u300.c b/drivers/clocksource/timer-u300.c
index 1744b243898a..704e40c6f151 100644
--- a/drivers/clocksource/timer-u300.c
+++ b/drivers/clocksource/timer-u300.c
@@ -359,27 +359,37 @@ static struct delay_timer u300_delay_timer;
 /*
 * This sets up the system timers, clock source and clock event.
 */
-static void __init u300_timer_init_of(struct device_node *np)
+static int __init u300_timer_init_of(struct device_node *np)
 {
        unsigned int irq;
        struct clk *clk;
        unsigned long rate;
+        int ret;
        u300_timer_base = of_iomap(np, 0);
-        if (!u300_timer_base)
+        if (!u300_timer_base) {
-                panic("could not ioremap system timer\n");
+                pr_err("could not ioremap system timer\n");
+                return -ENXIO;
+        }
        /* Get the IRQ for the GP1 timer */
        irq = irq_of_parse_and_map(np, 2);
-        if (!irq)
+        if (!irq) {
-                panic("no IRQ for system timer\n");
+                pr_err("no IRQ for system timer\n");
+                return -EINVAL;
+        }
        pr_info("U300 GP1 timer @ base: %p, IRQ: %u\n", u300_timer_base, irq);
        /* Clock the interrupt controller */
        clk = of_clk_get(np, 0);
-        BUG_ON(IS_ERR(clk));
+        if (IS_ERR(clk))
-        clk_prepare_enable(clk);
+                return PTR_ERR(clk);
+        ret = clk_prepare_enable(clk);
+        if (ret)
+                return ret;
        rate = clk_get_rate(clk);
        u300_clockevent_data.ticks_per_jiffy = DIV_ROUND_CLOSEST(rate, HZ);
@@ -410,7 +420,9 @@ static void __init u300_timer_init_of(struct device_node *np)
                u300_timer_base + U300_TIMER_APP_RGPT1);
        /* Set up the IRQ handler */
-        setup_irq(irq, &u300_timer_irq);
+        ret = setup_irq(irq, &u300_timer_irq);
+        if (ret)
+                return ret;
        /* Reset the General Purpose timer 2 */
        writel(U300_TIMER_APP_RGPT2_TIMER_RESET,
@@ -428,9 +440,12 @@ static void __init u300_timer_init_of(struct device_node *np)
                u300_timer_base + U300_TIMER_APP_EGPT2);
        /* Use general purpose timer 2 as clock source */
-        if (clocksource_mmio_init(u300_timer_base + U300_TIMER_APP_GPT2CC,
+        ret = clocksource_mmio_init(u300_timer_base + U300_TIMER_APP_GPT2CC,
-                        "GPT2", rate, 300, 32, clocksource_mmio_readl_up))
+                                    "GPT2", rate, 300, 32, clocksource_mmio_readl_up);
+        if (ret) {
                pr_err("timer: failed to initialize U300 clock source\n");
+                return ret;
+        }
        /* Configure and register the clockevent */
        clockevents_config_and_register(&u300_clockevent_data.cevd, rate,
@@ -440,6 +455,7 @@ static void __init u300_timer_init_of(struct device_node *np)
         * TODO: init and register the rest of the timers too, they can be
         * used by hrtimers!
         */
+        return 0;
 }
 CLOCKSOURCE_OF_DECLARE(u300_timer, "stericsson,u300-apptimer",
diff --git a/drivers/clocksource/versatile.c b/drivers/clocksource/versatile.c
index 0a26d3dde6c0..220b490a8142 100644
--- a/drivers/clocksource/versatile.c
+++ b/drivers/clocksource/versatile.c
@@ -25,16 +25,18 @@ static u64 notrace versatile_sys_24mhz_read(void)
        return readl(versatile_sys_24mhz);
 }
-static void __init versatile_sched_clock_init(struct device_node *node)
+static int __init versatile_sched_clock_init(struct device_node *node)
 {
        void __iomem *base = of_iomap(node, 0);
        if (!base)
-                return;
+                return -ENXIO;
        versatile_sys_24mhz = base + SYS_24MHZ;
        sched_clock_register(versatile_sys_24mhz_read, 32, 24000000);
+        return 0;
 }
 CLOCKSOURCE_OF_DECLARE(vexpress, "arm,vexpress-sysreg",
                       versatile_sched_clock_init);
diff --git a/drivers/clocksource/vf_pit_timer.c b/drivers/clocksource/vf_pit_timer.c
index a0e6c68536a1..55d8d8402d90 100644
--- a/drivers/clocksource/vf_pit_timer.c
+++ b/drivers/clocksource/vf_pit_timer.c
@@ -156,15 +156,18 @@ static int __init pit_clockevent_init(unsigned long rate, int irq)
        return 0;
 }
-static void __init pit_timer_init(struct device_node *np)
+static int __init pit_timer_init(struct device_node *np)
 {
        struct clk *pit_clk;
        void __iomem *timer_base;
        unsigned long clk_rate;
-        int irq;
+        int irq, ret;
        timer_base = of_iomap(np, 0);
-        BUG_ON(!timer_base);
+        if (!timer_base) {
+                pr_err("Failed to iomap");
+                return -ENXIO;
+        }
        /*
         * PIT0 and PIT1 can be chained to build a 64-bit timer,
@@ -175,12 +178,16 @@ static void __init pit_timer_init(struct device_node *np)
        clkevt_base = timer_base + PITn_OFFSET(3);
        irq = irq_of_parse_and_map(np, 0);
-        BUG_ON(irq <= 0);
+        if (irq <= 0)
+                return -EINVAL;
        pit_clk = of_clk_get(np, 0);
-        BUG_ON(IS_ERR(pit_clk));
+        if (IS_ERR(pit_clk))
+                return PTR_ERR(pit_clk);
-        BUG_ON(clk_prepare_enable(pit_clk));
+        ret = clk_prepare_enable(pit_clk);
+        if (ret)
+                return ret;
        clk_rate = clk_get_rate(pit_clk);
        cycle_per_jiffy = clk_rate / (HZ);
@@ -188,8 +195,10 @@ static void __init pit_timer_init(struct device_node *np)
        /* enable the pit module */
        __raw_writel(~PITMCR_MDIS, timer_base + PITMCR);
-        BUG_ON(pit_clocksource_init(clk_rate));
+        ret = pit_clocksource_init(clk_rate);
+        if (ret)
+                return ret;
-        pit_clockevent_init(clk_rate, irq);
+        return pit_clockevent_init(clk_rate, irq);
 }
 CLOCKSOURCE_OF_DECLARE(vf610, "fsl,vf610-pit", pit_timer_init);
diff --git a/drivers/clocksource/vt8500_timer.c b/drivers/clocksource/vt8500_timer.c
index ddb409274f45..b15069483fbd 100644
--- a/drivers/clocksource/vt8500_timer.c
+++ b/drivers/clocksource/vt8500_timer.c
@@ -121,38 +121,48 @@ static struct irqaction irq = {
        .dev_id  = &clockevent,
 };
-static void __init vt8500_timer_init(struct device_node *np)
+static int __init vt8500_timer_init(struct device_node *np)
 {
-        int timer_irq;
+        int timer_irq, ret;
        regbase = of_iomap(np, 0);
        if (!regbase) {
                pr_err("%s: Missing iobase description in Device Tree\n",
                                                                __func__);
-                return;
+                return -ENXIO;
        }
        timer_irq = irq_of_parse_and_map(np, 0);
        if (!timer_irq) {
                pr_err("%s: Missing irq description in Device Tree\n",
                                                                __func__);
-                return;
+                return -EINVAL;
        }
        writel(1, regbase + TIMER_CTRL_VAL);
        writel(0xf, regbase + TIMER_STATUS_VAL);
        writel(~0, regbase + TIMER_MATCH_VAL);
-        if (clocksource_register_hz(&clocksource, VT8500_TIMER_HZ))
+        ret = clocksource_register_hz(&clocksource, VT8500_TIMER_HZ);
+        if (ret) {
                pr_err("%s: vt8500_timer_init: clocksource_register failed for %s\n",
-                                        __func__, clocksource.name);
+                       __func__, clocksource.name);
+                return ret;
+        }
        clockevent.cpumask = cpumask_of(0);
-        if (setup_irq(timer_irq, &irq))
+        ret = setup_irq(timer_irq, &irq);
+        if (ret) {
                pr_err("%s: setup_irq failed for %s\n", __func__,
                                                        clockevent.name);
+                return ret;
+        }
        clockevents_config_and_register(&clockevent, VT8500_TIMER_HZ,
                                        MIN_OSCR_DELTA * 2, 0xf0000000);
+        return 0;
 }
 CLOCKSOURCE_OF_DECLARE(vt8500, "via,vt8500-timer", vt8500_timer_init);
diff --git a/drivers/clocksource/zevio-timer.c b/drivers/clocksource/zevio-timer.c
index ceaa6133f9c2..9a53f5ef6157 100644
--- a/drivers/clocksource/zevio-timer.c
+++ b/drivers/clocksource/zevio-timer.c
@@ -210,9 +210,9 @@ error_free:
        return ret;
 }
-static void __init zevio_timer_init(struct device_node *node)
+static int __init zevio_timer_init(struct device_node *node)
 {
-        BUG_ON(zevio_timer_add(node));
+        return zevio_timer_add(node);
 }
 CLOCKSOURCE_OF_DECLARE(zevio_timer, "lsi,zevio-timer", zevio_timer_init);
diff --git a/drivers/cpufreq/powernv-cpufreq.c b/drivers/cpufreq/powernv-cpufreq.c
index 54c45368e3f1..6bd715b7f11c 100644
--- a/drivers/cpufreq/powernv-cpufreq.c
+++ b/drivers/cpufreq/powernv-cpufreq.c
@@ -530,8 +530,7 @@ static inline void  queue_gpstate_timer(struct global_pstate_info *gpstates)
        else
                timer_interval = GPSTATE_TIMER_INTERVAL;
-        mod_timer_pinned(&gpstates->timer, jiffies +
+        mod_timer(&gpstates->timer, jiffies + msecs_to_jiffies(timer_interval));
-                        msecs_to_jiffies(timer_interval));
 }
 /**
@@ -699,7 +698,7 @@ static int powernv_cpufreq_cpu_init(struct cpufreq_policy *policy)
        policy->driver_data = gpstates;
        /* initialize timer */
-        init_timer_deferrable(&gpstates->timer);
+        init_timer_pinned_deferrable(&gpstates->timer);
        gpstates->timer.data = (unsigned long)policy;
        gpstates->timer.function = gpstate_timer_handler;
        gpstates->timer.expires = jiffies +
diff --git a/drivers/mmc/host/jz4740_mmc.c b/drivers/mmc/host/jz4740_mmc.c
index 03ddf0ecf402..684087db170b 100644
--- a/drivers/mmc/host/jz4740_mmc.c
+++ b/drivers/mmc/host/jz4740_mmc.c
@@ -1068,8 +1068,6 @@ static int jz4740_mmc_probe(struct platform_device* pdev)
        jz4740_mmc_clock_disable(host);
        setup_timer(&host->timeout_timer, jz4740_mmc_timeout,
                        (unsigned long)host);
-        /* It is not important when it times out, it just needs to timeout. */
-        set_timer_slack(&host->timeout_timer, HZ);
        host->use_dma = true;
        if (host->use_dma && jz4740_mmc_acquire_dma_channels(host) != 0)
diff --git a/drivers/net/ethernet/tile/tilepro.c b/drivers/net/ethernet/tile/tilepro.c
index 922a443e3415..4ef605a90247 100644
--- a/drivers/net/ethernet/tile/tilepro.c
+++ b/drivers/net/ethernet/tile/tilepro.c
@@ -588,7 +588,7 @@ static bool tile_net_lepp_free_comps(struct net_device *dev, bool all)
 static void tile_net_schedule_egress_timer(struct tile_net_cpu *info)
 {
        if (!info->egress_timer_scheduled) {
-                mod_timer_pinned(&info->egress_timer, jiffies + 1);
+                mod_timer(&info->egress_timer, jiffies + 1);
                info->egress_timer_scheduled = true;
        }
 }
@@ -1004,7 +1004,7 @@ static void tile_net_register(void *dev_ptr)
                BUG();
        /* Initialize the egress timer. */
-        init_timer(&info->egress_timer);
+        init_timer_pinned(&info->egress_timer);
        info->egress_timer.data = (long)info;
        info->egress_timer.function = tile_net_handle_egress_timer;
diff --git a/drivers/power/bq27xxx_battery.c b/drivers/power/bq27xxx_battery.c
index 45f6ebf88df6..e90b3f307e0f 100644
--- a/drivers/power/bq27xxx_battery.c
+++ b/drivers/power/bq27xxx_battery.c
@@ -735,11 +735,8 @@ static void bq27xxx_battery_poll(struct work_struct *work)
        bq27xxx_battery_update(di);
-        if (poll_interval > 0) {
+        if (poll_interval > 0)
-                /* The timer does not have to be accurate. */
-                set_timer_slack(&di->work.timer, poll_interval * HZ / 4);
                schedule_delayed_work(&di->work, poll_interval * HZ);
-        }
 }
 /*
diff --git a/drivers/tty/metag_da.c b/drivers/tty/metag_da.c
index 9325262289f9..25ccef2fe748 100644
--- a/drivers/tty/metag_da.c
+++ b/drivers/tty/metag_da.c
@@ -323,12 +323,12 @@ static void dashtty_timer(unsigned long ignored)
        if (channel >= 0)
                fetch_data(channel);
-        mod_timer_pinned(&poll_timer, jiffies + DA_TTY_POLL);
+        mod_timer(&poll_timer, jiffies + DA_TTY_POLL);
 }
 static void add_poll_timer(struct timer_list *poll_timer)
 {
-        setup_timer(poll_timer, dashtty_timer, 0);
+        setup_pinned_timer(poll_timer, dashtty_timer, 0);
        poll_timer->expires = jiffies + DA_TTY_POLL;
        /*
diff --git a/drivers/tty/mips_ejtag_fdc.c b/drivers/tty/mips_ejtag_fdc.c
index a119176a1855..234123b0c642 100644
--- a/drivers/tty/mips_ejtag_fdc.c
+++ b/drivers/tty/mips_ejtag_fdc.c
@@ -689,7 +689,7 @@ static void mips_ejtag_fdc_tty_timer(unsigned long opaque)
        mips_ejtag_fdc_handle(priv);
        if (!priv->removing)
-                mod_timer_pinned(&priv->poll_timer, jiffies + FDC_TTY_POLL);
+                mod_timer(&priv->poll_timer, jiffies + FDC_TTY_POLL);
 }
 /* TTY Port operations */
@@ -1002,7 +1002,7 @@ static int mips_ejtag_fdc_tty_probe(struct mips_cdmm_device *dev)
                raw_spin_unlock_irq(&priv->lock);
        } else {
                /* If we didn't get an usable IRQ, poll instead */
-                setup_timer(&priv->poll_timer, mips_ejtag_fdc_tty_timer,
+                setup_pinned_timer(&priv->poll_timer, mips_ejtag_fdc_tty_timer,
                            (unsigned long)priv);
                priv->poll_timer.expires = jiffies + FDC_TTY_POLL;
                /*
diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index 0449235d4f22..1700908b84ef 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -500,7 +500,6 @@ static int ohci_init (struct ohci_hcd *ohci)
        setup_timer(&ohci->io_watchdog, io_watchdog_func,
                        (unsigned long) ohci);
-        set_timer_slack(&ohci->io_watchdog, msecs_to_jiffies(20));
        ohci->hcca = dma_alloc_coherent (hcd->self.controller,
                        sizeof(*ohci->hcca), &ohci->hcca_dma, GFP_KERNEL);
diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index 9da98321d8e6..01d96c9b3a75 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -490,8 +490,6 @@ static void compliance_mode_recovery_timer_init(struct xhci_hcd *xhci)
        xhci->comp_mode_recovery_timer.expires = jiffies +
                        msecs_to_jiffies(COMP_MODE_RCVRY_MSECS);
-        set_timer_slack(&xhci->comp_mode_recovery_timer,
-                        msecs_to_jiffies(COMP_MODE_RCVRY_MSECS));
        add_timer(&xhci->comp_mode_recovery_timer);
        xhci_dbg_trace(xhci, trace_xhci_dbg_quirks,
                        "Compliance mode recovery timer initialized");
diff --git a/fs/timerfd.c b/fs/timerfd.c
index 053818dd6c18..9ae4abb4110b 100644
--- a/fs/timerfd.c
+++ b/fs/timerfd.c
@@ -390,6 +390,11 @@ SYSCALL_DEFINE2(timerfd_create, int, clockid, int, flags)
             clockid != CLOCK_BOOTTIME_ALARM))
                return -EINVAL;
+        if (!capable(CAP_WAKE_ALARM) &&
+            (clockid == CLOCK_REALTIME_ALARM ||
+             clockid == CLOCK_BOOTTIME_ALARM))
+                return -EPERM;
        ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
        if (!ctx)
                return -ENOMEM;
@@ -433,6 +438,11 @@ static int do_timerfd_settime(int ufd, int flags,
                return ret;
        ctx = f.file->private_data;
+        if (!capable(CAP_WAKE_ALARM) && isalarm(ctx)) {
+                fdput(f);
+                return -EPERM;
+        }
        timerfd_setup_cancel(ctx, flags);
        /*
diff --git a/include/clocksource/timer-sp804.h b/include/clocksource/timer-sp804.h
index 1f8a1caa7cb4..7654d71243dd 100644
--- a/include/clocksource/timer-sp804.h
+++ b/include/clocksource/timer-sp804.h
@@ -3,10 +3,10 @@
 struct clk;
-void __sp804_clocksource_and_sched_clock_init(void __iomem *,
+int __sp804_clocksource_and_sched_clock_init(void __iomem *,
-                                              const char *, struct clk *, int);
+                                             const char *, struct clk *, int);
-void __sp804_clockevents_init(void __iomem *, unsigned int,
+int __sp804_clockevents_init(void __iomem *, unsigned int,
-                              struct clk *, const char *);
+                             struct clk *, const char *);
 void sp804_timer_disable(void __iomem *);
 static inline void sp804_clocksource_init(void __iomem *base, const char *name)
diff --git a/include/linux/alarmtimer.h b/include/linux/alarmtimer.h
index 52f3b7da4f2d..9d8031257a90 100644
--- a/include/linux/alarmtimer.h
+++ b/include/linux/alarmtimer.h
@@ -26,10 +26,10 @@ enum alarmtimer_restart {
 * struct alarm - Alarm timer structure
 * @node:       timerqueue node for adding to the event list this value
 *              also includes the expiration time.
- * @period:     Period for recuring alarms
+ * @timer:      hrtimer used to schedule events while running
 * @function:   Function pointer to be executed when the timer fires.
- * @type:       Alarm type (BOOTTIME/REALTIME)
+ * @type:       Alarm type (BOOTTIME/REALTIME).
- * @enabled:    Flag that represents if the alarm is set to fire or not
+ * @state:      Flag that represents if the alarm is set to fire or not.
 * @data:       Internal data value.
 */
 struct alarm {
diff --git a/include/linux/clk.h b/include/linux/clk.h
index 0df4a51e1a78..834179f3fa72 100644
--- a/include/linux/clk.h
+++ b/include/linux/clk.h
@@ -461,6 +461,10 @@ static inline struct clk *clk_get_parent(struct clk *clk)
        return NULL;
 }
+static inline struct clk *clk_get_sys(const char *dev_id, const char *con_id)
+{
+        return NULL;
+}
 #endif
 /* clk_prepare_enable helps cases using clk_enable in non-atomic context. */
diff --git a/include/linux/clocksource.h b/include/linux/clocksource.h
index 44a1aff22566..08398182f56e 100644
--- a/include/linux/clocksource.h
+++ b/include/linux/clocksource.h
@@ -244,7 +244,7 @@ extern int clocksource_mmio_init(void __iomem *, const char *,
 extern int clocksource_i8253_init(void);
 #define CLOCKSOURCE_OF_DECLARE(name, compat, fn) \
-        OF_DECLARE_1(clksrc, name, compat, fn)
+        OF_DECLARE_1_RET(clksrc, name, compat, fn)
 #ifdef CONFIG_CLKSRC_PROBE
 extern void clocksource_probe(void);
diff --git a/include/linux/list.h b/include/linux/list.h
index 5356f4d661a7..5183138aa932 100644
--- a/include/linux/list.h
+++ b/include/linux/list.h
@@ -679,6 +679,16 @@ static inline bool hlist_fake(struct hlist_node *h)
 }
 /*
+ * Check whether the node is the only node of the head without
+ * accessing head:
+ */
+static inline bool
+hlist_is_singular_node(struct hlist_node *n, struct hlist_head *h)
+{
+        return !n->next && n->pprev == &h->first;
+}
+/*
 * Move a list from one list head to another. Fixup the pprev
 * reference of the first entry if it exists.
 */
diff --git a/include/linux/of.h b/include/linux/of.h
index 74eb28cadbef..15c43f076b23 100644
--- a/include/linux/of.h
+++ b/include/linux/of.h
@@ -1009,10 +1009,13 @@ static inline int of_get_available_child_count(const struct device_node *np)
 #endif
 typedef int (*of_init_fn_2)(struct device_node *, struct device_node *);
+typedef int (*of_init_fn_1_ret)(struct device_node *);
 typedef void (*of_init_fn_1)(struct device_node *);
 #define OF_DECLARE_1(table, name, compat, fn) \
                _OF_DECLARE(table, name, compat, fn, of_init_fn_1)
+#define OF_DECLARE_1_RET(table, name, compat, fn) \
+                _OF_DECLARE(table, name, compat, fn, of_init_fn_1_ret)
 #define OF_DECLARE_2(table, name, compat, fn) \
                _OF_DECLARE(table, name, compat, fn, of_init_fn_2)
diff --git a/include/linux/time.h b/include/linux/time.h
index 297f09f23896..4cea09d94208 100644
--- a/include/linux/time.h
+++ b/include/linux/time.h
@@ -205,7 +205,20 @@ struct tm {
        int tm_yday;
 };
-void time_to_tm(time_t totalsecs, int offset, struct tm *result);
+void time64_to_tm(time64_t totalsecs, int offset, struct tm *result);
+/**
+ * time_to_tm - converts the calendar time to local broken-down time
+ *
+ * @totalsecs   the number of seconds elapsed since 00:00:00 on January 1, 1970,
+ *              Coordinated Universal Time (UTC).
+ * @offset      offset seconds adding to totalsecs.
+ * @result      pointer to struct tm variable to receive broken-down time
+ */
+static inline void time_to_tm(time_t totalsecs, int offset, struct tm *result)
+{
+        time64_to_tm(totalsecs, offset, result);
+}
 /**
 * timespec_to_ns - Convert timespec to nanoseconds
diff --git a/include/linux/timer.h b/include/linux/timer.h
index 20ac746f3eb3..4419506b564e 100644
--- a/include/linux/timer.h
+++ b/include/linux/timer.h
@@ -19,7 +19,6 @@ struct timer_list {
        void                    (*function)(unsigned long);
        unsigned long           data;
        u32                     flags;
-        int                     slack;
 #ifdef CONFIG_TIMER_STATS
        int                     start_pid;
@@ -58,11 +57,14 @@ struct timer_list {
 * workqueue locking issues. It's not meant for executing random crap
 * with interrupts disabled. Abuse is monitored!
 */
-#define TIMER_CPUMASK           0x0007FFFF
+#define TIMER_CPUMASK           0x0003FFFF
-#define TIMER_MIGRATING         0x00080000
+#define TIMER_MIGRATING         0x00040000
 #define TIMER_BASEMASK          (TIMER_CPUMASK | TIMER_MIGRATING)
-#define TIMER_DEFERRABLE        0x00100000
+#define TIMER_DEFERRABLE        0x00080000
+#define TIMER_PINNED            0x00100000
 #define TIMER_IRQSAFE           0x00200000
+#define TIMER_ARRAYSHIFT        22
+#define TIMER_ARRAYMASK         0xFFC00000
 #define __TIMER_INITIALIZER(_function, _expires, _data, _flags) { \
                .entry = { .next = TIMER_ENTRY_STATIC },        \
@@ -70,7 +72,6 @@ struct timer_list {
                .expires = (_expires),                          \
                .data = (_data),                                \
                .flags = (_flags),                              \
-                .slack = -1,                                    \
                __TIMER_LOCKDEP_MAP_INITIALIZER(                \
                        __FILE__ ":" __stringify(__LINE__))     \
        }
@@ -78,9 +79,15 @@ struct timer_list {
 #define TIMER_INITIALIZER(_function, _expires, _data)           \
        __TIMER_INITIALIZER((_function), (_expires), (_data), 0)
+#define TIMER_PINNED_INITIALIZER(_function, _expires, _data)    \
+        __TIMER_INITIALIZER((_function), (_expires), (_data), TIMER_PINNED)
 #define TIMER_DEFERRED_INITIALIZER(_function, _expires, _data)  \
        __TIMER_INITIALIZER((_function), (_expires), (_data), TIMER_DEFERRABLE)
+#define TIMER_PINNED_DEFERRED_INITIALIZER(_function, _expires, _data)   \
+        __TIMER_INITIALIZER((_function), (_expires), (_data), TIMER_DEFERRABLE | TIMER_PINNED)
 #define DEFINE_TIMER(_name, _function, _expires, _data)         \
        struct timer_list _name =                               \
                TIMER_INITIALIZER(_function, _expires, _data)
@@ -124,8 +131,12 @@ static inline void init_timer_on_stack_key(struct timer_list *timer,
 #define init_timer(timer)                                               \
        __init_timer((timer), 0)
+#define init_timer_pinned(timer)                                        \
+        __init_timer((timer), TIMER_PINNED)
 #define init_timer_deferrable(timer)                                    \
        __init_timer((timer), TIMER_DEFERRABLE)
+#define init_timer_pinned_deferrable(timer)                             \
+        __init_timer((timer), TIMER_DEFERRABLE | TIMER_PINNED)
 #define init_timer_on_stack(timer)                                      \
        __init_timer_on_stack((timer), 0)
@@ -145,12 +156,20 @@ static inline void init_timer_on_stack_key(struct timer_list *timer,
 #define setup_timer(timer, fn, data)                                    \
        __setup_timer((timer), (fn), (data), 0)
+#define setup_pinned_timer(timer, fn, data)                             \
+        __setup_timer((timer), (fn), (data), TIMER_PINNED)
 #define setup_deferrable_timer(timer, fn, data)                         \
        __setup_timer((timer), (fn), (data), TIMER_DEFERRABLE)
+#define setup_pinned_deferrable_timer(timer, fn, data)                  \
+        __setup_timer((timer), (fn), (data), TIMER_DEFERRABLE | TIMER_PINNED)
 #define setup_timer_on_stack(timer, fn, data)                           \
        __setup_timer_on_stack((timer), (fn), (data), 0)
+#define setup_pinned_timer_on_stack(timer, fn, data)                    \
+        __setup_timer_on_stack((timer), (fn), (data), TIMER_PINNED)
 #define setup_deferrable_timer_on_stack(timer, fn, data)                \
        __setup_timer_on_stack((timer), (fn), (data), TIMER_DEFERRABLE)
+#define setup_pinned_deferrable_timer_on_stack(timer, fn, data)         \
+        __setup_timer_on_stack((timer), (fn), (data), TIMER_DEFERRABLE | TIMER_PINNED)
 /**
 * timer_pending - is a timer pending?
@@ -171,12 +190,7 @@ extern void add_timer_on(struct timer_list *timer, int cpu);
 extern int del_timer(struct timer_list * timer);
 extern int mod_timer(struct timer_list *timer, unsigned long expires);
 extern int mod_timer_pending(struct timer_list *timer, unsigned long expires);
-extern int mod_timer_pinned(struct timer_list *timer, unsigned long expires);
-extern void set_timer_slack(struct timer_list *time, int slack_hz);
-#define TIMER_NOT_PINNED        0
-#define TIMER_PINNED            1
 /*
 * The jiffies value which is added to now, when there is no timer
 * in the timer wheel:
diff --git a/kernel/signal.c b/kernel/signal.c
index 96e9bc40667f..af21afc00d08 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -2751,23 +2751,18 @@ int copy_siginfo_to_user(siginfo_t __user *to, const siginfo_t *from)
 *  @ts: upper bound on process time suspension
 */
 int do_sigtimedwait(const sigset_t *which, siginfo_t *info,
-                        const struct timespec *ts)
+                    const struct timespec *ts)
 {
+        ktime_t *to = NULL, timeout = { .tv64 = KTIME_MAX };
        struct task_struct *tsk = current;
-        long timeout = MAX_SCHEDULE_TIMEOUT;
        sigset_t mask = *which;
-        int sig;
+        int sig, ret = 0;
        if (ts) {
                if (!timespec_valid(ts))
                        return -EINVAL;
-                timeout = timespec_to_jiffies(ts);
+                timeout = timespec_to_ktime(*ts);
-                /*
+                to = &timeout;
-                 * We can be close to the next tick, add another one
-                 * to ensure we will wait at least the time asked for.
-                 */
-                if (ts->tv_sec || ts->tv_nsec)
-                        timeout++;
        }
        /*
@@ -2778,7 +2773,7 @@ int do_sigtimedwait(const sigset_t *which, siginfo_t *info,
        spin_lock_irq(&tsk->sighand->siglock);
        sig = dequeue_signal(tsk, &mask, info);
-        if (!sig && timeout) {
+        if (!sig && timeout.tv64) {
                /*
                 * None ready, temporarily unblock those we're interested
                 * while we are sleeping in so that we'll be awakened when
@@ -2790,8 +2785,9 @@ int do_sigtimedwait(const sigset_t *which, siginfo_t *info,
                recalc_sigpending();
                spin_unlock_irq(&tsk->sighand->siglock);
-                timeout = freezable_schedule_timeout_interruptible(timeout);
+                __set_current_state(TASK_INTERRUPTIBLE);
+                ret = freezable_schedule_hrtimeout_range(to, tsk->timer_slack_ns,
+                                                         HRTIMER_MODE_REL);
                spin_lock_irq(&tsk->sighand->siglock);
                __set_task_blocked(tsk, &tsk->real_blocked);
                sigemptyset(&tsk->real_blocked);
@@ -2801,7 +2797,7 @@ int do_sigtimedwait(const sigset_t *which, siginfo_t *info,
        if (sig)
                return sig;
-        return timeout ? -EINTR : -EAGAIN;
+        return ret ? -EINTR : -EAGAIN;
 }
 /**
diff --git a/kernel/time/alarmtimer.c b/kernel/time/alarmtimer.c
index e840ed867a5d..c3aad685bbc0 100644
--- a/kernel/time/alarmtimer.c
+++ b/kernel/time/alarmtimer.c
@@ -30,7 +30,6 @@
 * struct alarm_base - Alarm timer bases
 * @lock:               Lock for syncrhonized access to the base
 * @timerqueue:         Timerqueue head managing the list of events
- * @timer:              hrtimer used to schedule events while running
 * @gettime:            Function to read the time correlating to the base
 * @base_clockid:       clockid for the base
 */
diff --git a/kernel/time/clockevents.c b/kernel/time/clockevents.c
index a9b76a40319e..2c5bc77c0bb0 100644
--- a/kernel/time/clockevents.c
+++ b/kernel/time/clockevents.c
@@ -645,7 +645,7 @@ void tick_cleanup_dead_cpu(int cpu)
 #endif
 #ifdef CONFIG_SYSFS
-struct bus_type clockevents_subsys = {
+static struct bus_type clockevents_subsys = {
        .name           = "clockevents",
        .dev_name       = "clockevent",
 };
diff --git a/kernel/time/clocksource.c b/kernel/time/clocksource.c
index 56ece145a814..6a5a310a1a53 100644
--- a/kernel/time/clocksource.c
+++ b/kernel/time/clocksource.c
@@ -669,10 +669,12 @@ static void clocksource_enqueue(struct clocksource *cs)
        struct list_head *entry = &clocksource_list;
        struct clocksource *tmp;
-        list_for_each_entry(tmp, &clocksource_list, list)
+        list_for_each_entry(tmp, &clocksource_list, list) {
                /* Keep track of the place, where to insert */
-                if (tmp->rating >= cs->rating)
+                if (tmp->rating < cs->rating)
-                        entry = &tmp->list;
+                        break;
+                entry = &tmp->list;
+        }
        list_add(&cs->list, entry);
 }
diff --git a/kernel/time/hrtimer.c b/kernel/time/hrtimer.c
index e99df0ff1d42..d13c9aebf7a3 100644
--- a/kernel/time/hrtimer.c
+++ b/kernel/time/hrtimer.c
@@ -177,7 +177,7 @@ hrtimer_check_target(struct hrtimer *timer, struct hrtimer_clock_base *new_base)
 #endif
 }
-#if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON)
+#ifdef CONFIG_NO_HZ_COMMON
 static inline
 struct hrtimer_cpu_base *get_target_base(struct hrtimer_cpu_base *base,
                                         int pinned)
diff --git a/kernel/time/test_udelay.c b/kernel/time/test_udelay.c
index e622ba365a13..b0928ab3270f 100644
--- a/kernel/time/test_udelay.c
+++ b/kernel/time/test_udelay.c
@@ -43,13 +43,13 @@ static int udelay_test_single(struct seq_file *s, int usecs, uint32_t iters)
        int allowed_error_ns = usecs * 5;
        for (i = 0; i < iters; ++i) {
-                struct timespec ts1, ts2;
+                s64 kt1, kt2;
                int time_passed;
-                ktime_get_ts(&ts1);
+                kt1 = ktime_get_ns();
                udelay(usecs);
-                ktime_get_ts(&ts2);
+                kt2 = ktime_get_ns();
-                time_passed = timespec_to_ns(&ts2) - timespec_to_ns(&ts1);
+                time_passed = kt2 - kt1;
                if (i == 0 || time_passed < min)
                        min = time_passed;
@@ -87,11 +87,11 @@ static int udelay_test_show(struct seq_file *s, void *v)
        if (usecs > 0 && iters > 0) {
                return udelay_test_single(s, usecs, iters);
        } else if (usecs == 0) {
-                struct timespec ts;
+                struct timespec64 ts;
-                ktime_get_ts(&ts);
+                ktime_get_ts64(&ts);
-                seq_printf(s, "udelay() test (lpj=%ld kt=%ld.%09ld)\n",
+                seq_printf(s, "udelay() test (lpj=%ld kt=%lld.%09ld)\n",
-                                loops_per_jiffy, ts.tv_sec, ts.tv_nsec);
+                                loops_per_jiffy, (s64)ts.tv_sec, ts.tv_nsec);
                seq_puts(s, "usage:\n");
                seq_puts(s, "echo USECS [ITERS] > " DEBUGFS_FILENAME "\n");
                seq_puts(s, "cat " DEBUGFS_FILENAME "\n");
diff --git a/kernel/time/tick-broadcast-hrtimer.c b/kernel/time/tick-broadcast-hrtimer.c
index 53d7184da0be..690b797f522e 100644
--- a/kernel/time/tick-broadcast-hrtimer.c
+++ b/kernel/time/tick-broadcast-hrtimer.c
@@ -75,6 +75,7 @@ static int bc_set_next(ktime_t expires, struct clock_event_device *bc)
 }
 static struct clock_event_device ce_broadcast_hrtimer = {
+        .name                   = "bc_hrtimer",
        .set_state_shutdown     = bc_shutdown,
        .set_next_ktime         = bc_set_next,
        .features               = CLOCK_EVT_FEAT_ONESHOT |
diff --git a/kernel/time/tick-internal.h b/kernel/time/tick-internal.h
index 966a5a6fdd0a..f738251000fe 100644
--- a/kernel/time/tick-internal.h
+++ b/kernel/time/tick-internal.h
@@ -164,3 +164,4 @@ static inline void timers_update_migration(bool update_nohz) { }
 DECLARE_PER_CPU(struct hrtimer_cpu_base, hrtimer_bases);
 extern u64 get_next_timer_interrupt(unsigned long basej, u64 basem);
+void timer_clear_idle(void);
diff --git a/kernel/time/tick-sched.c b/kernel/time/tick-sched.c
index 536ada80f6dd..204fdc86863d 100644
--- a/kernel/time/tick-sched.c
+++ b/kernel/time/tick-sched.c
@@ -31,7 +31,7 @@
 #include <trace/events/timer.h>
 /*
- * Per cpu nohz control structure
+ * Per-CPU nohz control structure
 */
 static DEFINE_PER_CPU(struct tick_sched, tick_cpu_sched);
@@ -61,7 +61,7 @@ static void tick_do_update_jiffies64(ktime_t now)
        if (delta.tv64 < tick_period.tv64)
                return;
-        /* Reevalute with jiffies_lock held */
+        /* Reevaluate with jiffies_lock held */
        write_seqlock(&jiffies_lock);
        delta = ktime_sub(now, last_jiffies_update);
@@ -116,8 +116,8 @@ static void tick_sched_do_timer(ktime_t now)
 #ifdef CONFIG_NO_HZ_COMMON
        /*
         * Check if the do_timer duty was dropped. We don't care about
-         * concurrency: This happens only when the cpu in charge went
+         * concurrency: This happens only when the CPU in charge went
-         * into a long sleep. If two cpus happen to assign themself to
+         * into a long sleep. If two CPUs happen to assign themselves to
         * this duty, then the jiffies update is still serialized by
         * jiffies_lock.
         */
@@ -349,7 +349,7 @@ void tick_nohz_dep_clear_signal(struct signal_struct *sig, enum tick_dep_bits bi
 /*
 * Re-evaluate the need for the tick as we switch the current task.
 * It might need the tick due to per task/process properties:
- * perf events, posix cpu timers, ...
+ * perf events, posix CPU timers, ...
 */
 void __tick_nohz_task_switch(void)
 {
@@ -509,8 +509,8 @@ int tick_nohz_tick_stopped(void)
 *
 * In case the sched_tick was stopped on this CPU, we have to check if jiffies
 * must be updated. Otherwise an interrupt handler could use a stale jiffy
- * value. We do this unconditionally on any cpu, as we don't know whether the
+ * value. We do this unconditionally on any CPU, as we don't know whether the
- * cpu, which has the update task assigned is in a long sleep.
+ * CPU, which has the update task assigned is in a long sleep.
 */
 static void tick_nohz_update_jiffies(ktime_t now)
 {
@@ -526,7 +526,7 @@ static void tick_nohz_update_jiffies(ktime_t now)
 }
 /*
- * Updates the per cpu time idle statistics counters
+ * Updates the per-CPU time idle statistics counters
 */
 static void
 update_ts_time_stats(int cpu, struct tick_sched *ts, ktime_t now, u64 *last_update_time)
@@ -566,12 +566,12 @@ static ktime_t tick_nohz_start_idle(struct tick_sched *ts)
 }
 /**
- * get_cpu_idle_time_us - get the total idle time of a cpu
+ * get_cpu_idle_time_us - get the total idle time of a CPU
 * @cpu: CPU number to query
 * @last_update_time: variable to store update time in. Do not update
 * counters if NULL.
 *
- * Return the cummulative idle time (since boot) for a given
+ * Return the cumulative idle time (since boot) for a given
 * CPU, in microseconds.
 *
 * This time is measured via accounting rather than sampling,
@@ -607,12 +607,12 @@ u64 get_cpu_idle_time_us(int cpu, u64 *last_update_time)
 EXPORT_SYMBOL_GPL(get_cpu_idle_time_us);
 /**
- * get_cpu_iowait_time_us - get the total iowait time of a cpu
+ * get_cpu_iowait_time_us - get the total iowait time of a CPU
 * @cpu: CPU number to query
 * @last_update_time: variable to store update time in. Do not update
 * counters if NULL.
 *
- * Return the cummulative iowait time (since boot) for a given
+ * Return the cumulative iowait time (since boot) for a given
 * CPU, in microseconds.
 *
 * This time is measured via accounting rather than sampling,
@@ -700,6 +700,12 @@ static ktime_t tick_nohz_stop_sched_tick(struct tick_sched *ts,
        delta = next_tick - basemono;
        if (delta <= (u64)TICK_NSEC) {
                tick.tv64 = 0;
+                /*
+                 * Tell the timer code that the base is not idle, i.e. undo
+                 * the effect of get_next_timer_interrupt():
+                 */
+                timer_clear_idle();
                /*
                 * We've not stopped the tick yet, and there's a timer in the
                 * next period, so no point in stopping it either, bail.
@@ -726,14 +732,14 @@ static ktime_t tick_nohz_stop_sched_tick(struct tick_sched *ts,
        }
        /*
-         * If this cpu is the one which updates jiffies, then give up
+         * If this CPU is the one which updates jiffies, then give up
-         * the assignment and let it be taken by the cpu which runs
+         * the assignment and let it be taken by the CPU which runs
-         * the tick timer next, which might be this cpu as well. If we
+         * the tick timer next, which might be this CPU as well. If we
         * don't drop this here the jiffies might be stale and
         * do_timer() never invoked. Keep track of the fact that it
-         * was the one which had the do_timer() duty last. If this cpu
+         * was the one which had the do_timer() duty last. If this CPU
         * is the one which had the do_timer() duty last, we limit the
-         * sleep time to the timekeeping max_deferement value.
+         * sleep time to the timekeeping max_deferment value.
         * Otherwise we can sleep as long as we want.
         */
        delta = timekeeping_max_deferment();
@@ -809,6 +815,12 @@ static void tick_nohz_restart_sched_tick(struct tick_sched *ts, ktime_t now)
        tick_do_update_jiffies64(now);
        cpu_load_update_nohz_stop();
+        /*
+         * Clear the timer idle flag, so we avoid IPIs on remote queueing and
+         * the clock forward checks in the enqueue path:
+         */
+        timer_clear_idle();
        calc_load_exit_idle();
        touch_softlockup_watchdog_sched();
        /*
@@ -841,9 +853,9 @@ static void tick_nohz_full_update_tick(struct tick_sched *ts)
 static bool can_stop_idle_tick(int cpu, struct tick_sched *ts)
 {
        /*
-         * If this cpu is offline and it is the one which updates
+         * If this CPU is offline and it is the one which updates
         * jiffies, then give up the assignment and let it be taken by
-         * the cpu which runs the tick timer next. If we don't drop
+         * the CPU which runs the tick timer next. If we don't drop
         * this here the jiffies might be stale and do_timer() never
         * invoked.
         */
@@ -896,11 +908,10 @@ static void __tick_nohz_idle_enter(struct tick_sched *ts)
        ktime_t now, expires;
        int cpu = smp_processor_id();
-        now = tick_nohz_start_idle(ts);
        if (can_stop_idle_tick(cpu, ts)) {
                int was_stopped = ts->tick_stopped;
+                now = tick_nohz_start_idle(ts);
                ts->idle_calls++;
                expires = tick_nohz_stop_sched_tick(ts, now, cpu);
@@ -933,11 +944,11 @@ void tick_nohz_idle_enter(void)
        WARN_ON_ONCE(irqs_disabled());
        /*
-         * Update the idle state in the scheduler domain hierarchy
+         * Update the idle state in the scheduler domain hierarchy
-         * when tick_nohz_stop_sched_tick() is called from the idle loop.
+         * when tick_nohz_stop_sched_tick() is called from the idle loop.
-         * State will be updated to busy during the first busy tick after
+         * State will be updated to busy during the first busy tick after
-         * exiting idle.
+         * exiting idle.
-         */
+         */
        set_cpu_sd_state_idle();
        local_irq_disable();
@@ -1092,35 +1103,6 @@ static void tick_nohz_switch_to_nohz(void)
        tick_nohz_activate(ts, NOHZ_MODE_LOWRES);
 }
-/*
- * When NOHZ is enabled and the tick is stopped, we need to kick the
- * tick timer from irq_enter() so that the jiffies update is kept
- * alive during long running softirqs. That's ugly as hell, but
- * correctness is key even if we need to fix the offending softirq in
- * the first place.
- *
- * Note, this is different to tick_nohz_restart. We just kick the
- * timer and do not touch the other magic bits which need to be done
- * when idle is left.
- */
-static void tick_nohz_kick_tick(struct tick_sched *ts, ktime_t now)
-{
-#if 0
-        /* Switch back to 2.6.27 behaviour */
-        ktime_t delta;
-        /*
-         * Do not touch the tick device, when the next expiry is either
-         * already reached or less/equal than the tick period.
-         */
-        delta = ktime_sub(hrtimer_get_expires(&ts->sched_timer), now);
-        if (delta.tv64 <= tick_period.tv64)
-                return;
-        tick_nohz_restart(ts, now);
-#endif
-}
 static inline void tick_nohz_irq_enter(void)
 {
        struct tick_sched *ts = this_cpu_ptr(&tick_cpu_sched);
@@ -1131,10 +1113,8 @@ static inline void tick_nohz_irq_enter(void)
        now = ktime_get();
        if (ts->idle_active)
                tick_nohz_stop_idle(ts, now);
-        if (ts->tick_stopped) {
+        if (ts->tick_stopped)
                tick_nohz_update_jiffies(now);
-                tick_nohz_kick_tick(ts, now);
-        }
 }
 #else
@@ -1211,7 +1191,7 @@ void tick_setup_sched_timer(void)
        hrtimer_init(&ts->sched_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
        ts->sched_timer.function = tick_sched_timer;
-        /* Get the next period (per cpu) */
+        /* Get the next period (per-CPU) */
        hrtimer_set_expires(&ts->sched_timer, tick_init_jiffy_update());
        /* Offset the tick to avert jiffies_lock contention. */
diff --git a/kernel/time/timeconv.c b/kernel/time/timeconv.c
index 86628e755f38..7142580ad94f 100644
--- a/kernel/time/timeconv.c
+++ b/kernel/time/timeconv.c
@@ -67,20 +67,21 @@ static const unsigned short __mon_yday[2][13] = {
 #define SECS_PER_DAY    (SECS_PER_HOUR * 24)
 /**
- * time_to_tm - converts the calendar time to local broken-down time
+ * time64_to_tm - converts the calendar time to local broken-down time
 *
 * @totalsecs   the number of seconds elapsed since 00:00:00 on January 1, 1970,
 *              Coordinated Universal Time (UTC).
 * @offset      offset seconds adding to totalsecs.
 * @result      pointer to struct tm variable to receive broken-down time
 */
-void time_to_tm(time_t totalsecs, int offset, struct tm *result)
+void time64_to_tm(time64_t totalsecs, int offset, struct tm *result)
 {
        long days, rem, y;
+        int remainder;
        const unsigned short *ip;
-        days = totalsecs / SECS_PER_DAY;
+        days = div_s64_rem(totalsecs, SECS_PER_DAY, &remainder);
-        rem = totalsecs % SECS_PER_DAY;
+        rem = remainder;
        rem += offset;
        while (rem < 0) {
                rem += SECS_PER_DAY;
@@ -124,4 +125,4 @@ void time_to_tm(time_t totalsecs, int offset, struct tm *result)
        result->tm_mon = y;
        result->tm_mday = days + 1;
 }
-EXPORT_SYMBOL(time_to_tm);
+EXPORT_SYMBOL(time64_to_tm);
diff --git a/kernel/time/timekeeping.c b/kernel/time/timekeeping.c
index 255e225393ac..3b65746c7f15 100644
--- a/kernel/time/timekeeping.c
+++ b/kernel/time/timekeeping.c
@@ -480,10 +480,12 @@ static inline void old_vsyscall_fixup(struct timekeeper *tk)
        * users are removed, this can be killed.
        */
        remainder = tk->tkr_mono.xtime_nsec & ((1ULL << tk->tkr_mono.shift) - 1);
-        tk->tkr_mono.xtime_nsec -= remainder;
+        if (remainder != 0) {
-        tk->tkr_mono.xtime_nsec += 1ULL << tk->tkr_mono.shift;
+                tk->tkr_mono.xtime_nsec -= remainder;
-        tk->ntp_error += remainder << tk->ntp_error_shift;
+                tk->tkr_mono.xtime_nsec += 1ULL << tk->tkr_mono.shift;
-        tk->ntp_error -= (1ULL << tk->tkr_mono.shift) << tk->ntp_error_shift;
+                tk->ntp_error += remainder << tk->ntp_error_shift;
+                tk->ntp_error -= (1ULL << tk->tkr_mono.shift) << tk->ntp_error_shift;
+        }
 }
 #else
 #define old_vsyscall_fixup(tk)
diff --git a/kernel/time/timer.c b/kernel/time/timer.c
index 3a95f9728778..cb9ab401e2d9 100644
--- a/kernel/time/timer.c
+++ b/kernel/time/timer.c
@@ -59,43 +59,153 @@ __visible u64 jiffies_64 __cacheline_aligned_in_smp = INITIAL_JIFFIES;
 EXPORT_SYMBOL(jiffies_64);
 /*
- * per-CPU timer vector definitions:
+ * The timer wheel has LVL_DEPTH array levels. Each level provides an array of
+ * LVL_SIZE buckets. Each level is driven by its own clock and therefor each
+ * level has a different granularity.
+ *
+ * The level granularity is:            LVL_CLK_DIV ^ lvl
+ * The level clock frequency is:        HZ / (LVL_CLK_DIV ^ level)
+ *
+ * The array level of a newly armed timer depends on the relative expiry
+ * time. The farther the expiry time is away the higher the array level and
+ * therefor the granularity becomes.
+ *
+ * Contrary to the original timer wheel implementation, which aims for 'exact'
+ * expiry of the timers, this implementation removes the need for recascading
+ * the timers into the lower array levels. The previous 'classic' timer wheel
+ * implementation of the kernel already violated the 'exact' expiry by adding
+ * slack to the expiry time to provide batched expiration. The granularity
+ * levels provide implicit batching.
+ *
+ * This is an optimization of the original timer wheel implementation for the
+ * majority of the timer wheel use cases: timeouts. The vast majority of
+ * timeout timers (networking, disk I/O ...) are canceled before expiry. If
+ * the timeout expires it indicates that normal operation is disturbed, so it
+ * does not matter much whether the timeout comes with a slight delay.
+ *
+ * The only exception to this are networking timers with a small expiry
+ * time. They rely on the granularity. Those fit into the first wheel level,
+ * which has HZ granularity.
+ *
+ * We don't have cascading anymore. timers with a expiry time above the
+ * capacity of the last wheel level are force expired at the maximum timeout
+ * value of the last wheel level. From data sampling we know that the maximum
+ * value observed is 5 days (network connection tracking), so this should not
+ * be an issue.
+ *
+ * The currently chosen array constants values are a good compromise between
+ * array size and granularity.
+ *
+ * This results in the following granularity and range levels:
+ *
+ * HZ 1000 steps
+ * Level Offset  Granularity            Range
+ *  0      0         1 ms                0 ms -         63 ms
+ *  1     64         8 ms               64 ms -        511 ms
+ *  2    128        64 ms              512 ms -       4095 ms (512ms - ~4s)
+ *  3    192       512 ms             4096 ms -      32767 ms (~4s - ~32s)
+ *  4    256      4096 ms (~4s)      32768 ms -     262143 ms (~32s - ~4m)
+ *  5    320     32768 ms (~32s)    262144 ms -    2097151 ms (~4m - ~34m)
+ *  6    384    262144 ms (~4m)    2097152 ms -   16777215 ms (~34m - ~4h)
+ *  7    448   2097152 ms (~34m)  16777216 ms -  134217727 ms (~4h - ~1d)
+ *  8    512  16777216 ms (~4h)  134217728 ms - 1073741822 ms (~1d - ~12d)
+ *
+ * HZ  300
+ * Level Offset  Granularity            Range
+ *  0      0         3 ms                0 ms -        210 ms
+ *  1     64        26 ms              213 ms -       1703 ms (213ms - ~1s)
+ *  2    128       213 ms             1706 ms -      13650 ms (~1s - ~13s)
+ *  3    192      1706 ms (~1s)      13653 ms -     109223 ms (~13s - ~1m)
+ *  4    256     13653 ms (~13s)    109226 ms -     873810 ms (~1m - ~14m)
+ *  5    320    109226 ms (~1m)     873813 ms -    6990503 ms (~14m - ~1h)
+ *  6    384    873813 ms (~14m)   6990506 ms -   55924050 ms (~1h - ~15h)
+ *  7    448   6990506 ms (~1h)   55924053 ms -  447392423 ms (~15h - ~5d)
+ *  8    512  55924053 ms (~15h) 447392426 ms - 3579139406 ms (~5d - ~41d)
+ *
+ * HZ  250
+ * Level Offset  Granularity            Range
+ *  0      0         4 ms                0 ms -        255 ms
+ *  1     64        32 ms              256 ms -       2047 ms (256ms - ~2s)
+ *  2    128       256 ms             2048 ms -      16383 ms (~2s - ~16s)
+ *  3    192      2048 ms (~2s)      16384 ms -     131071 ms (~16s - ~2m)
+ *  4    256     16384 ms (~16s)    131072 ms -    1048575 ms (~2m - ~17m)
+ *  5    320    131072 ms (~2m)    1048576 ms -    8388607 ms (~17m - ~2h)
+ *  6    384   1048576 ms (~17m)   8388608 ms -   67108863 ms (~2h - ~18h)
+ *  7    448   8388608 ms (~2h)   67108864 ms -  536870911 ms (~18h - ~6d)
+ *  8    512  67108864 ms (~18h) 536870912 ms - 4294967288 ms (~6d - ~49d)
+ *
+ * HZ  100
+ * Level Offset  Granularity            Range
+ *  0      0         10 ms               0 ms -        630 ms
+ *  1     64         80 ms             640 ms -       5110 ms (640ms - ~5s)
+ *  2    128        640 ms            5120 ms -      40950 ms (~5s - ~40s)
+ *  3    192       5120 ms (~5s)     40960 ms -     327670 ms (~40s - ~5m)
+ *  4    256      40960 ms (~40s)   327680 ms -    2621430 ms (~5m - ~43m)
+ *  5    320     327680 ms (~5m)   2621440 ms -   20971510 ms (~43m - ~5h)
+ *  6    384    2621440 ms (~43m) 20971520 ms -  167772150 ms (~5h - ~1d)
+ *  7    448   20971520 ms (~5h) 167772160 ms - 1342177270 ms (~1d - ~15d)
 */
-#define TVN_BITS (CONFIG_BASE_SMALL ? 4 : 6)
-#define TVR_BITS (CONFIG_BASE_SMALL ? 6 : 8)
-#define TVN_SIZE (1 << TVN_BITS)
-#define TVR_SIZE (1 << TVR_BITS)
-#define TVN_MASK (TVN_SIZE - 1)
-#define TVR_MASK (TVR_SIZE - 1)
-#define MAX_TVAL ((unsigned long)((1ULL << (TVR_BITS + 4*TVN_BITS)) - 1))
-struct tvec {
-        struct hlist_head vec[TVN_SIZE];
-};
-struct tvec_root {
+/* Clock divisor for the next level */
-        struct hlist_head vec[TVR_SIZE];
+#define LVL_CLK_SHIFT   3
-};
+#define LVL_CLK_DIV     (1UL << LVL_CLK_SHIFT)
+#define LVL_CLK_MASK    (LVL_CLK_DIV - 1)
+#define LVL_SHIFT(n)    ((n) * LVL_CLK_SHIFT)
+#define LVL_GRAN(n)     (1UL << LVL_SHIFT(n))
-struct tvec_base {
+/*
-        spinlock_t lock;
+ * The time start value for each level to select the bucket at enqueue
-        struct timer_list *running_timer;
+ * time.
-        unsigned long timer_jiffies;
+ */
-        unsigned long next_timer;
+#define LVL_START(n)    ((LVL_SIZE - 1) << (((n) - 1) * LVL_CLK_SHIFT))
-        unsigned long active_timers;
-        unsigned long all_timers;
+/* Size of each clock level */
-        int cpu;
+#define LVL_BITS        6
-        bool migration_enabled;
+#define LVL_SIZE        (1UL << LVL_BITS)
-        bool nohz_active;
+#define LVL_MASK        (LVL_SIZE - 1)
-        struct tvec_root tv1;
+#define LVL_OFFS(n)     ((n) * LVL_SIZE)
-        struct tvec tv2;
-        struct tvec tv3;
+/* Level depth */
-        struct tvec tv4;
+#if HZ > 100
-        struct tvec tv5;
+# define LVL_DEPTH      9
-} ____cacheline_aligned;
+# else
+# define LVL_DEPTH      8
+#endif
+/* The cutoff (max. capacity of the wheel) */
+#define WHEEL_TIMEOUT_CUTOFF    (LVL_START(LVL_DEPTH))
+#define WHEEL_TIMEOUT_MAX       (WHEEL_TIMEOUT_CUTOFF - LVL_GRAN(LVL_DEPTH - 1))
+/*
+ * The resulting wheel size. If NOHZ is configured we allocate two
+ * wheels so we have a separate storage for the deferrable timers.
+ */
+#define WHEEL_SIZE      (LVL_SIZE * LVL_DEPTH)
+#ifdef CONFIG_NO_HZ_COMMON
+# define NR_BASES       2
+# define BASE_STD       0
+# define BASE_DEF       1
+#else
+# define NR_BASES       1
+# define BASE_STD       0
+# define BASE_DEF       0
+#endif
+struct timer_base {
+        spinlock_t              lock;
+        struct timer_list       *running_timer;
+        unsigned long           clk;
+        unsigned long           next_expiry;
+        unsigned int            cpu;
+        bool                    migration_enabled;
+        bool                    nohz_active;
+        bool                    is_idle;
+        DECLARE_BITMAP(pending_map, WHEEL_SIZE);
+        struct hlist_head       vectors[WHEEL_SIZE];
+} ____cacheline_aligned;
-static DEFINE_PER_CPU(struct tvec_base, tvec_bases);
+static DEFINE_PER_CPU(struct timer_base, timer_bases[NR_BASES]);
 #if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON)
 unsigned int sysctl_timer_migration = 1;
@@ -106,15 +216,17 @@ void timers_update_migration(bool update_nohz)
        unsigned int cpu;
        /* Avoid the loop, if nothing to update */
-        if (this_cpu_read(tvec_bases.migration_enabled) == on)
+        if (this_cpu_read(timer_bases[BASE_STD].migration_enabled) == on)
                return;
        for_each_possible_cpu(cpu) {
-                per_cpu(tvec_bases.migration_enabled, cpu) = on;
+                per_cpu(timer_bases[BASE_STD].migration_enabled, cpu) = on;
+                per_cpu(timer_bases[BASE_DEF].migration_enabled, cpu) = on;
                per_cpu(hrtimer_bases.migration_enabled, cpu) = on;
                if (!update_nohz)
                        continue;
-                per_cpu(tvec_bases.nohz_active, cpu) = true;
+                per_cpu(timer_bases[BASE_STD].nohz_active, cpu) = true;
+                per_cpu(timer_bases[BASE_DEF].nohz_active, cpu) = true;
                per_cpu(hrtimer_bases.nohz_active, cpu) = true;
        }
 }
@@ -133,20 +245,6 @@ int timer_migration_handler(struct ctl_table *table, int write,
        mutex_unlock(&mutex);
        return ret;
 }
-static inline struct tvec_base *get_target_base(struct tvec_base *base,
-                                                int pinned)
-{
-        if (pinned || !base->migration_enabled)
-                return this_cpu_ptr(&tvec_bases);
-        return per_cpu_ptr(&tvec_bases, get_nohz_timer_target());
-}
-#else
-static inline struct tvec_base *get_target_base(struct tvec_base *base,
-                                                int pinned)
-{
-        return this_cpu_ptr(&tvec_bases);
-}
 #endif
 static unsigned long round_jiffies_common(unsigned long j, int cpu,
@@ -351,101 +449,126 @@ unsigned long round_jiffies_up_relative(unsigned long j)
 }
 EXPORT_SYMBOL_GPL(round_jiffies_up_relative);
-/**
- * set_timer_slack - set the allowed slack for a timer
+static inline unsigned int timer_get_idx(struct timer_list *timer)
- * @timer: the timer to be modified
- * @slack_hz: the amount of time (in jiffies) allowed for rounding
- *
- * Set the amount of time, in jiffies, that a certain timer has
- * in terms of slack. By setting this value, the timer subsystem
- * will schedule the actual timer somewhere between
- * the time mod_timer() asks for, and that time plus the slack.
- *
- * By setting the slack to -1, a percentage of the delay is used
- * instead.
- */
-void set_timer_slack(struct timer_list *timer, int slack_hz)
 {
-        timer->slack = slack_hz;
+        return (timer->flags & TIMER_ARRAYMASK) >> TIMER_ARRAYSHIFT;
 }
-EXPORT_SYMBOL_GPL(set_timer_slack);
-static void
+static inline void timer_set_idx(struct timer_list *timer, unsigned int idx)
-__internal_add_timer(struct tvec_base *base, struct timer_list *timer)
 {
-        unsigned long expires = timer->expires;
+        timer->flags = (timer->flags & ~TIMER_ARRAYMASK) |
-        unsigned long idx = expires - base->timer_jiffies;
+                        idx << TIMER_ARRAYSHIFT;
-        struct hlist_head *vec;
+}
-        if (idx < TVR_SIZE) {
+/*
-                int i = expires & TVR_MASK;
+ * Helper function to calculate the array index for a given expiry
-                vec = base->tv1.vec + i;
+ * time.
-        } else if (idx < 1 << (TVR_BITS + TVN_BITS)) {
+ */
-                int i = (expires >> TVR_BITS) & TVN_MASK;
+static inline unsigned calc_index(unsigned expires, unsigned lvl)
-                vec = base->tv2.vec + i;
+{
-        } else if (idx < 1 << (TVR_BITS + 2 * TVN_BITS)) {
+        expires = (expires + LVL_GRAN(lvl)) >> LVL_SHIFT(lvl);
-                int i = (expires >> (TVR_BITS + TVN_BITS)) & TVN_MASK;
+        return LVL_OFFS(lvl) + (expires & LVL_MASK);
-                vec = base->tv3.vec + i;
+}
-        } else if (idx < 1 << (TVR_BITS + 3 * TVN_BITS)) {
-                int i = (expires >> (TVR_BITS + 2 * TVN_BITS)) & TVN_MASK;
+static int calc_wheel_index(unsigned long expires, unsigned long clk)
-                vec = base->tv4.vec + i;
+{
-        } else if ((signed long) idx < 0) {
+        unsigned long delta = expires - clk;
-                /*
+        unsigned int idx;
-                 * Can happen if you add a timer with expires == jiffies,
-                 * or you set a timer to go off in the past
+        if (delta < LVL_START(1)) {
-                 */
+                idx = calc_index(expires, 0);
-                vec = base->tv1.vec + (base->timer_jiffies & TVR_MASK);
+        } else if (delta < LVL_START(2)) {
+                idx = calc_index(expires, 1);
+        } else if (delta < LVL_START(3)) {
+                idx = calc_index(expires, 2);
+        } else if (delta < LVL_START(4)) {
+                idx = calc_index(expires, 3);
+        } else if (delta < LVL_START(5)) {
+                idx = calc_index(expires, 4);
+        } else if (delta < LVL_START(6)) {
+                idx = calc_index(expires, 5);
+        } else if (delta < LVL_START(7)) {
+                idx = calc_index(expires, 6);
+        } else if (LVL_DEPTH > 8 && delta < LVL_START(8)) {
+                idx = calc_index(expires, 7);
+        } else if ((long) delta < 0) {
+                idx = clk & LVL_MASK;
        } else {
-                int i;
+                /*
-                /* If the timeout is larger than MAX_TVAL (on 64-bit
+                 * Force expire obscene large timeouts to expire at the
-                 * architectures or with CONFIG_BASE_SMALL=1) then we
+                 * capacity limit of the wheel.
-                 * use the maximum timeout.
                 */
-                if (idx > MAX_TVAL) {
+                if (expires >= WHEEL_TIMEOUT_CUTOFF)
-                        idx = MAX_TVAL;
+                        expires = WHEEL_TIMEOUT_MAX;
-                        expires = idx + base->timer_jiffies;
-                }
+                idx = calc_index(expires, LVL_DEPTH - 1);
-                i = (expires >> (TVR_BITS + 3 * TVN_BITS)) & TVN_MASK;
-                vec = base->tv5.vec + i;
        }
+        return idx;
+}
-        hlist_add_head(&timer->entry, vec);
+/*
+ * Enqueue the timer into the hash bucket, mark it pending in
+ * the bitmap and store the index in the timer flags.
+ */
+static void enqueue_timer(struct timer_base *base, struct timer_list *timer,
+                          unsigned int idx)
+{
+        hlist_add_head(&timer->entry, base->vectors + idx);
+        __set_bit(idx, base->pending_map);
+        timer_set_idx(timer, idx);
 }
-static void internal_add_timer(struct tvec_base *base, struct timer_list *timer)
+static void
+__internal_add_timer(struct timer_base *base, struct timer_list *timer)
 {
-        /* Advance base->jiffies, if the base is empty */
+        unsigned int idx;
-        if (!base->all_timers++)
-                base->timer_jiffies = jiffies;
+        idx = calc_wheel_index(timer->expires, base->clk);
+        enqueue_timer(base, timer, idx);
+}
+static void
+trigger_dyntick_cpu(struct timer_base *base, struct timer_list *timer)
+{
+        if (!IS_ENABLED(CONFIG_NO_HZ_COMMON) || !base->nohz_active)
+                return;
-        __internal_add_timer(base, timer);
        /*
-         * Update base->active_timers and base->next_timer
+         * TODO: This wants some optimizing similar to the code below, but we
+         * will do that when we switch from push to pull for deferrable timers.
         */
-        if (!(timer->flags & TIMER_DEFERRABLE)) {
+        if (timer->flags & TIMER_DEFERRABLE) {
-                if (!base->active_timers++ ||
+                if (tick_nohz_full_cpu(base->cpu))
-                    time_before(timer->expires, base->next_timer))
+                        wake_up_nohz_cpu(base->cpu);
-                        base->next_timer = timer->expires;
+                return;
        }
        /*
-         * Check whether the other CPU is in dynticks mode and needs
+         * We might have to IPI the remote CPU if the base is idle and the
-         * to be triggered to reevaluate the timer wheel.
+         * timer is not deferrable. If the other CPU is on the way to idle
-         * We are protected against the other CPU fiddling
+         * then it can't set base->is_idle as we hold the base lock:
-         * with the timer by holding the timer base lock. This also
-         * makes sure that a CPU on the way to stop its tick can not
-         * evaluate the timer wheel.
-         *
-         * Spare the IPI for deferrable timers on idle targets though.
-         * The next busy ticks will take care of it. Except full dynticks
-         * require special care against races with idle_cpu(), lets deal
-         * with that later.
         */
-        if (base->nohz_active) {
+        if (!base->is_idle)
-                if (!(timer->flags & TIMER_DEFERRABLE) ||
+                return;
-                    tick_nohz_full_cpu(base->cpu))
-                        wake_up_nohz_cpu(base->cpu);
+        /* Check whether this is the new first expiring timer: */
-        }
+        if (time_after_eq(timer->expires, base->next_expiry))
+                return;
+        /*
+         * Set the next expiry time and kick the CPU so it can reevaluate the
+         * wheel:
+         */
+        base->next_expiry = timer->expires;
+                wake_up_nohz_cpu(base->cpu);
+}
+static void
+internal_add_timer(struct timer_base *base, struct timer_list *timer)
+{
+        __internal_add_timer(base, timer);
+        trigger_dyntick_cpu(base, timer);
 }
 #ifdef CONFIG_TIMER_STATS
@@ -666,7 +789,6 @@ static void do_init_timer(struct timer_list *timer, unsigned int flags,
 {
        timer->entry.pprev = NULL;
        timer->flags = flags | raw_smp_processor_id();
-        timer->slack = -1;
 #ifdef CONFIG_TIMER_STATS
        timer->start_site = NULL;
        timer->start_pid = -1;
@@ -706,54 +828,125 @@ static inline void detach_timer(struct timer_list *timer, bool clear_pending)
        entry->next = LIST_POISON2;
 }
-static inline void
+static int detach_if_pending(struct timer_list *timer, struct timer_base *base,
-detach_expired_timer(struct timer_list *timer, struct tvec_base *base)
-{
-        detach_timer(timer, true);
-        if (!(timer->flags & TIMER_DEFERRABLE))
-                base->active_timers--;
-        base->all_timers--;
-}
-static int detach_if_pending(struct timer_list *timer, struct tvec_base *base,
                             bool clear_pending)
 {
+        unsigned idx = timer_get_idx(timer);
        if (!timer_pending(timer))
                return 0;
+        if (hlist_is_singular_node(&timer->entry, base->vectors + idx))
+                __clear_bit(idx, base->pending_map);
        detach_timer(timer, clear_pending);
-        if (!(timer->flags & TIMER_DEFERRABLE)) {
-                base->active_timers--;
-                if (timer->expires == base->next_timer)
-                        base->next_timer = base->timer_jiffies;
-        }
-        /* If this was the last timer, advance base->jiffies */
-        if (!--base->all_timers)
-                base->timer_jiffies = jiffies;
        return 1;
 }
+static inline struct timer_base *get_timer_cpu_base(u32 tflags, u32 cpu)
+{
+        struct timer_base *base = per_cpu_ptr(&timer_bases[BASE_STD], cpu);
+        /*
+         * If the timer is deferrable and nohz is active then we need to use
+         * the deferrable base.
+         */
+        if (IS_ENABLED(CONFIG_NO_HZ_COMMON) && base->nohz_active &&
+            (tflags & TIMER_DEFERRABLE))
+                base = per_cpu_ptr(&timer_bases[BASE_DEF], cpu);
+        return base;
+}
+static inline struct timer_base *get_timer_this_cpu_base(u32 tflags)
+{
+        struct timer_base *base = this_cpu_ptr(&timer_bases[BASE_STD]);
+        /*
+         * If the timer is deferrable and nohz is active then we need to use
+         * the deferrable base.
+         */
+        if (IS_ENABLED(CONFIG_NO_HZ_COMMON) && base->nohz_active &&
+            (tflags & TIMER_DEFERRABLE))
+                base = this_cpu_ptr(&timer_bases[BASE_DEF]);
+        return base;
+}
+static inline struct timer_base *get_timer_base(u32 tflags)
+{
+        return get_timer_cpu_base(tflags, tflags & TIMER_CPUMASK);
+}
+#ifdef CONFIG_NO_HZ_COMMON
+static inline struct timer_base *
+__get_target_base(struct timer_base *base, unsigned tflags)
+{
+#ifdef CONFIG_SMP
+        if ((tflags & TIMER_PINNED) || !base->migration_enabled)
+                return get_timer_this_cpu_base(tflags);
+        return get_timer_cpu_base(tflags, get_nohz_timer_target());
+#else
+        return get_timer_this_cpu_base(tflags);
+#endif
+}
+static inline void forward_timer_base(struct timer_base *base)
+{
+        /*
+         * We only forward the base when it's idle and we have a delta between
+         * base clock and jiffies.
+         */
+        if (!base->is_idle || (long) (jiffies - base->clk) < 2)
+                return;
+        /*
+         * If the next expiry value is > jiffies, then we fast forward to
+         * jiffies otherwise we forward to the next expiry value.
+         */
+        if (time_after(base->next_expiry, jiffies))
+                base->clk = jiffies;
+        else
+                base->clk = base->next_expiry;
+}
+#else
+static inline struct timer_base *
+__get_target_base(struct timer_base *base, unsigned tflags)
+{
+        return get_timer_this_cpu_base(tflags);
+}
+static inline void forward_timer_base(struct timer_base *base) { }
+#endif
+static inline struct timer_base *
+get_target_base(struct timer_base *base, unsigned tflags)
+{
+        struct timer_base *target = __get_target_base(base, tflags);
+        forward_timer_base(target);
+        return target;
+}
 /*
- * We are using hashed locking: holding per_cpu(tvec_bases).lock
+ * We are using hashed locking: Holding per_cpu(timer_bases[x]).lock means
- * means that all timers which are tied to this base via timer->base are
+ * that all timers which are tied to this base are locked, and the base itself
- * locked, and the base itself is locked too.
+ * is locked too.
 *
 * So __run_timers/migrate_timers can safely modify all timers which could
- * be found on ->tvX lists.
+ * be found in the base->vectors array.
 *
- * When the timer's base is locked and removed from the list, the
+ * When a timer is migrating then the TIMER_MIGRATING flag is set and we need
- * TIMER_MIGRATING flag is set, FIXME
+ * to wait until the migration is done.
 */
-static struct tvec_base *lock_timer_base(struct timer_list *timer,
+static struct timer_base *lock_timer_base(struct timer_list *timer,
-                                        unsigned long *flags)
+                                          unsigned long *flags)
        __acquires(timer->base->lock)
 {
        for (;;) {
+                struct timer_base *base;
                u32 tf = timer->flags;
-                struct tvec_base *base;
                if (!(tf & TIMER_MIGRATING)) {
-                        base = per_cpu_ptr(&tvec_bases, tf & TIMER_CPUMASK);
+                        base = get_timer_base(tf);
                        spin_lock_irqsave(&base->lock, *flags);
                        if (timer->flags == tf)
                                return base;
@@ -764,13 +957,41 @@ static struct tvec_base *lock_timer_base(struct timer_list *timer,
 }
 static inline int
-__mod_timer(struct timer_list *timer, unsigned long expires,
+__mod_timer(struct timer_list *timer, unsigned long expires, bool pending_only)
-            bool pending_only, int pinned)
 {
-        struct tvec_base *base, *new_base;
+        struct timer_base *base, *new_base;
-        unsigned long flags;
+        unsigned int idx = UINT_MAX;
+        unsigned long clk = 0, flags;
        int ret = 0;
+        /*
+         * This is a common optimization triggered by the networking code - if
+         * the timer is re-modified to have the same timeout or ends up in the
+         * same array bucket then just return:
+         */
+        if (timer_pending(timer)) {
+                if (timer->expires == expires)
+                        return 1;
+                /*
+                 * Take the current timer_jiffies of base, but without holding
+                 * the lock!
+                 */
+                base = get_timer_base(timer->flags);
+                clk = base->clk;
+                idx = calc_wheel_index(expires, clk);
+                /*
+                 * Retrieve and compare the array index of the pending
+                 * timer. If it matches set the expiry to the new value so a
+                 * subsequent call will exit in the expires check above.
+                 */
+                if (idx == timer_get_idx(timer)) {
+                        timer->expires = expires;
+                        return 1;
+                }
+        }
        timer_stats_timer_set_start_info(timer);
        BUG_ON(!timer->function);
@@ -782,15 +1003,15 @@ __mod_timer(struct timer_list *timer, unsigned long expires,
        debug_activate(timer, expires);
-        new_base = get_target_base(base, pinned);
+        new_base = get_target_base(base, timer->flags);
        if (base != new_base) {
                /*
-                 * We are trying to schedule the timer on the local CPU.
+                 * We are trying to schedule the timer on the new base.
                 * However we can't change timer's base while it is running,
                 * otherwise del_timer_sync() can't detect that the timer's
-                 * handler yet has not finished. This also guarantees that
+                 * handler yet has not finished. This also guarantees that the
-                 * the timer is serialized wrt itself.
+                 * timer is serialized wrt itself.
                 */
                if (likely(base->running_timer != timer)) {
                        /* See the comment in lock_timer_base() */
@@ -805,7 +1026,18 @@ __mod_timer(struct timer_list *timer, unsigned long expires,
        }
        timer->expires = expires;
-        internal_add_timer(base, timer);
+        /*
+         * If 'idx' was calculated above and the base time did not advance
+         * between calculating 'idx' and taking the lock, only enqueue_timer()
+         * and trigger_dyntick_cpu() is required. Otherwise we need to
+         * (re)calculate the wheel index via internal_add_timer().
+         */
+        if (idx != UINT_MAX && clk == base->clk) {
+                enqueue_timer(base, timer, idx);
+                trigger_dyntick_cpu(base, timer);
+        } else {
+                internal_add_timer(base, timer);
+        }
 out_unlock:
        spin_unlock_irqrestore(&base->lock, flags);
@@ -825,49 +1057,10 @@ out_unlock:
 */
 int mod_timer_pending(struct timer_list *timer, unsigned long expires)
 {
-        return __mod_timer(timer, expires, true, TIMER_NOT_PINNED);
+        return __mod_timer(timer, expires, true);
 }
 EXPORT_SYMBOL(mod_timer_pending);
-/*
- * Decide where to put the timer while taking the slack into account
- *
- * Algorithm:
- *   1) calculate the maximum (absolute) time
- *   2) calculate the highest bit where the expires and new max are different
- *   3) use this bit to make a mask
- *   4) use the bitmask to round down the maximum time, so that all last
- *      bits are zeros
- */
-static inline
-unsigned long apply_slack(struct timer_list *timer, unsigned long expires)
-{
-        unsigned long expires_limit, mask;
-        int bit;
-        if (timer->slack >= 0) {
-                expires_limit = expires + timer->slack;
-        } else {
-                long delta = expires - jiffies;
-                if (delta < 256)
-                        return expires;
-                expires_limit = expires + delta / 256;
-        }
-        mask = expires ^ expires_limit;
-        if (mask == 0)
-                return expires;
-        bit = __fls(mask);
-        mask = (1UL << bit) - 1;
-        expires_limit = expires_limit & ~(mask);
-        return expires_limit;
-}
 /**
 * mod_timer - modify a timer's timeout
 * @timer: the timer to be modified
@@ -890,49 +1083,11 @@ unsigned long apply_slack(struct timer_list *timer, unsigned long expires)
 */
 int mod_timer(struct timer_list *timer, unsigned long expires)
 {
-        expires = apply_slack(timer, expires);
+        return __mod_timer(timer, expires, false);
-        /*
-         * This is a common optimization triggered by the
-         * networking code - if the timer is re-modified
-         * to be the same thing then just return:
-         */
-        if (timer_pending(timer) && timer->expires == expires)
-                return 1;
-        return __mod_timer(timer, expires, false, TIMER_NOT_PINNED);
 }
 EXPORT_SYMBOL(mod_timer);
 /**
- * mod_timer_pinned - modify a timer's timeout
- * @timer: the timer to be modified
- * @expires: new timeout in jiffies
- *
- * mod_timer_pinned() is a way to update the expire field of an
- * active timer (if the timer is inactive it will be activated)
- * and to ensure that the timer is scheduled on the current CPU.
- *
- * Note that this does not prevent the timer from being migrated
- * when the current CPU goes offline.  If this is a problem for
- * you, use CPU-hotplug notifiers to handle it correctly, for
- * example, cancelling the timer when the corresponding CPU goes
- * offline.
- *
- * mod_timer_pinned(timer, expires) is equivalent to:
- *
- *     del_timer(timer); timer->expires = expires; add_timer(timer);
- */
-int mod_timer_pinned(struct timer_list *timer, unsigned long expires)
-{
-        if (timer->expires == expires && timer_pending(timer))
-                return 1;
-        return __mod_timer(timer, expires, false, TIMER_PINNED);
-}
-EXPORT_SYMBOL(mod_timer_pinned);
-/**
 * add_timer - start a timer
 * @timer: the timer to be added
 *
@@ -962,13 +1117,14 @@ EXPORT_SYMBOL(add_timer);
 */
 void add_timer_on(struct timer_list *timer, int cpu)
 {
-        struct tvec_base *new_base = per_cpu_ptr(&tvec_bases, cpu);
+        struct timer_base *new_base, *base;
-        struct tvec_base *base;
        unsigned long flags;
        timer_stats_timer_set_start_info(timer);
        BUG_ON(timer_pending(timer) || !timer->function);
+        new_base = get_timer_cpu_base(timer->flags, cpu);
        /*
         * If @timer was on a different CPU, it should be migrated with the
         * old base locked to prevent other operations proceeding with the
@@ -1004,7 +1160,7 @@ EXPORT_SYMBOL_GPL(add_timer_on);
 */
 int del_timer(struct timer_list *timer)
 {
-        struct tvec_base *base;
+        struct timer_base *base;
        unsigned long flags;
        int ret = 0;
@@ -1030,7 +1186,7 @@ EXPORT_SYMBOL(del_timer);
 */
 int try_to_del_timer_sync(struct timer_list *timer)
 {
-        struct tvec_base *base;
+        struct timer_base *base;
        unsigned long flags;
        int ret = -1;
@@ -1114,27 +1270,6 @@ int del_timer_sync(struct timer_list *timer)
 EXPORT_SYMBOL(del_timer_sync);
 #endif
-static int cascade(struct tvec_base *base, struct tvec *tv, int index)
-{
-        /* cascade all the timers from tv up one level */
-        struct timer_list *timer;
-        struct hlist_node *tmp;
-        struct hlist_head tv_list;
-        hlist_move_list(tv->vec + index, &tv_list);
-        /*
-         * We are removing _all_ timers from the list, so we
-         * don't have to detach them individually.
-         */
-        hlist_for_each_entry_safe(timer, tmp, &tv_list, entry) {
-                /* No accounting, while moving them */
-                __internal_add_timer(base, timer);
-        }
-        return index;
-}
 static void call_timer_fn(struct timer_list *timer, void (*fn)(unsigned long),
                          unsigned long data)
 {
@@ -1178,147 +1313,141 @@ static void call_timer_fn(struct timer_list *timer, void (*fn)(unsigned long),
        }
 }
-#define INDEX(N) ((base->timer_jiffies >> (TVR_BITS + (N) * TVN_BITS)) & TVN_MASK)
+static void expire_timers(struct timer_base *base, struct hlist_head *head)
-/**
- * __run_timers - run all expired timers (if any) on this CPU.
- * @base: the timer vector to be processed.
- *
- * This function cascades all vectors and executes all expired timer
- * vectors.
- */
-static inline void __run_timers(struct tvec_base *base)
 {
-        struct timer_list *timer;
+        while (!hlist_empty(head)) {
+                struct timer_list *timer;
+                void (*fn)(unsigned long);
+                unsigned long data;
-        spin_lock_irq(&base->lock);
+                timer = hlist_entry(head->first, struct timer_list, entry);
+                timer_stats_account_timer(timer);
-        while (time_after_eq(jiffies, base->timer_jiffies)) {
+                base->running_timer = timer;
-                struct hlist_head work_list;
+                detach_timer(timer, true);
-                struct hlist_head *head = &work_list;
-                int index;
-                if (!base->all_timers) {
+                fn = timer->function;
-                        base->timer_jiffies = jiffies;
+                data = timer->data;
-                        break;
+                if (timer->flags & TIMER_IRQSAFE) {
+                        spin_unlock(&base->lock);
+                        call_timer_fn(timer, fn, data);
+                        spin_lock(&base->lock);
+                } else {
+                        spin_unlock_irq(&base->lock);
+                        call_timer_fn(timer, fn, data);
+                        spin_lock_irq(&base->lock);
                }
+        }
+}
-                index = base->timer_jiffies & TVR_MASK;
+static int __collect_expired_timers(struct timer_base *base,
+                                    struct hlist_head *heads)
+{
+        unsigned long clk = base->clk;
+        struct hlist_head *vec;
+        int i, levels = 0;
+        unsigned int idx;
-                /*
+        for (i = 0; i < LVL_DEPTH; i++) {
-                 * Cascade timers:
+                idx = (clk & LVL_MASK) + i * LVL_SIZE;
-                 */
-                if (!index &&
+                if (__test_and_clear_bit(idx, base->pending_map)) {
-                        (!cascade(base, &base->tv2, INDEX(0))) &&
+                        vec = base->vectors + idx;
-                                (!cascade(base, &base->tv3, INDEX(1))) &&
+                        hlist_move_list(vec, heads++);
-                                        !cascade(base, &base->tv4, INDEX(2)))
+                        levels++;
-                        cascade(base, &base->tv5, INDEX(3));
-                ++base->timer_jiffies;
-                hlist_move_list(base->tv1.vec + index, head);
-                while (!hlist_empty(head)) {
-                        void (*fn)(unsigned long);
-                        unsigned long data;
-                        bool irqsafe;
-                        timer = hlist_entry(head->first, struct timer_list, entry);
-                        fn = timer->function;
-                        data = timer->data;
-                        irqsafe = timer->flags & TIMER_IRQSAFE;
-                        timer_stats_account_timer(timer);
-                        base->running_timer = timer;
-                        detach_expired_timer(timer, base);
-                        if (irqsafe) {
-                                spin_unlock(&base->lock);
-                                call_timer_fn(timer, fn, data);
-                                spin_lock(&base->lock);
-                        } else {
-                                spin_unlock_irq(&base->lock);
-                                call_timer_fn(timer, fn, data);
-                                spin_lock_irq(&base->lock);
-                        }
                }
+                /* Is it time to look at the next level? */
+                if (clk & LVL_CLK_MASK)
+                        break;
+                /* Shift clock for the next level granularity */
+                clk >>= LVL_CLK_SHIFT;
        }
-        base->running_timer = NULL;
+        return levels;
-        spin_unlock_irq(&base->lock);
 }
 #ifdef CONFIG_NO_HZ_COMMON
 /*
- * Find out when the next timer event is due to happen. This
+ * Find the next pending bucket of a level. Search from level start (@offset)
- * is used on S/390 to stop all activity when a CPU is idle.
+ * + @clk upwards and if nothing there, search from start of the level
- * This function needs to be called with interrupts disabled.
+ * (@offset) up to @offset + clk.
 */
-static unsigned long __next_timer_interrupt(struct tvec_base *base)
+static int next_pending_bucket(struct timer_base *base, unsigned offset,
-{
+                               unsigned clk)
-        unsigned long timer_jiffies = base->timer_jiffies;
+{
-        unsigned long expires = timer_jiffies + NEXT_TIMER_MAX_DELTA;
+        unsigned pos, start = offset + clk;
-        int index, slot, array, found = 0;
+        unsigned end = offset + LVL_SIZE;
-        struct timer_list *nte;
-        struct tvec *varray[4];
+        pos = find_next_bit(base->pending_map, end, start);
+        if (pos < end)
-        /* Look for timer events in tv1. */
+                return pos - start;
-        index = slot = timer_jiffies & TVR_MASK;
-        do {
+        pos = find_next_bit(base->pending_map, start, offset);
-                hlist_for_each_entry(nte, base->tv1.vec + slot, entry) {
+        return pos < start ? pos + LVL_SIZE - start : -1;
-                        if (nte->flags & TIMER_DEFERRABLE)
+}
-                                continue;
+/*
-                        found = 1;
+ * Search the first expiring timer in the various clock levels. Caller must
-                        expires = nte->expires;
+ * hold base->lock.
-                        /* Look at the cascade bucket(s)? */
+ */
-                        if (!index || slot < index)
+static unsigned long __next_timer_interrupt(struct timer_base *base)
-                                goto cascade;
+{
-                        return expires;
+        unsigned long clk, next, adj;
+        unsigned lvl, offset = 0;
+        next = base->clk + NEXT_TIMER_MAX_DELTA;
+        clk = base->clk;
+        for (lvl = 0; lvl < LVL_DEPTH; lvl++, offset += LVL_SIZE) {
+                int pos = next_pending_bucket(base, offset, clk & LVL_MASK);
+                if (pos >= 0) {
+                        unsigned long tmp = clk + (unsigned long) pos;
+                        tmp <<= LVL_SHIFT(lvl);
+                        if (time_before(tmp, next))
+                                next = tmp;
                }
-                slot = (slot + 1) & TVR_MASK;
+                /*
-        } while (slot != index);
+                 * Clock for the next level. If the current level clock lower
+                 * bits are zero, we look at the next level as is. If not we
-cascade:
+                 * need to advance it by one because that's going to be the
-        /* Calculate the next cascade event */
+                 * next expiring bucket in that level. base->clk is the next
-        if (index)
+                 * expiring jiffie. So in case of:
-                timer_jiffies += TVR_SIZE - index;
+                 *
-        timer_jiffies >>= TVR_BITS;
+                 * LVL5 LVL4 LVL3 LVL2 LVL1 LVL0
+                 *  0    0    0    0    0    0
-        /* Check tv2-tv5. */
+                 *
-        varray[0] = &base->tv2;
+                 * we have to look at all levels @index 0. With
-        varray[1] = &base->tv3;
+                 *
-        varray[2] = &base->tv4;
+                 * LVL5 LVL4 LVL3 LVL2 LVL1 LVL0
-        varray[3] = &base->tv5;
+                 *  0    0    0    0    0    2
+                 *
-        for (array = 0; array < 4; array++) {
+                 * LVL0 has the next expiring bucket @index 2. The upper
-                struct tvec *varp = varray[array];
+                 * levels have the next expiring bucket @index 1.
+                 *
-                index = slot = timer_jiffies & TVN_MASK;
+                 * In case that the propagation wraps the next level the same
-                do {
+                 * rules apply:
-                        hlist_for_each_entry(nte, varp->vec + slot, entry) {
+                 *
-                                if (nte->flags & TIMER_DEFERRABLE)
+                 * LVL5 LVL4 LVL3 LVL2 LVL1 LVL0
-                                        continue;
+                 *  0    0    0    0    F    2
+                 *
-                                found = 1;
+                 * So after looking at LVL0 we get:
-                                if (time_before(nte->expires, expires))
+                 *
-                                        expires = nte->expires;
+                 * LVL5 LVL4 LVL3 LVL2 LVL1
-                        }
+                 *  0    0    0    1    0
-                        /*
+                 *
-                         * Do we still search for the first timer or are
+                 * So no propagation from LVL1 to LVL2 because that happened
-                         * we looking up the cascade buckets ?
+                 * with the add already, but then we need to propagate further
-                         */
+                 * from LVL2 to LVL3.
-                        if (found) {
+                 *
-                                /* Look at the cascade bucket(s)? */
+                 * So the simple check whether the lower bits of the current
-                                if (!index || slot < index)
+                 * level are 0 or not is sufficient for all cases.
-                                        break;
+                 */
-                                return expires;
+                adj = clk & LVL_CLK_MASK ? 1 : 0;
-                        }
+                clk >>= LVL_CLK_SHIFT;
-                        slot = (slot + 1) & TVN_MASK;
+                clk += adj;
-                } while (slot != index);
-                if (index)
-                        timer_jiffies += TVN_SIZE - index;
-                timer_jiffies >>= TVN_BITS;
        }
-        return expires;
+        return next;
 }
 /*
@@ -1364,7 +1493,7 @@ static u64 cmp_next_hrtimer_event(u64 basem, u64 expires)
 */
 u64 get_next_timer_interrupt(unsigned long basej, u64 basem)
 {
-        struct tvec_base *base = this_cpu_ptr(&tvec_bases);
+        struct timer_base *base = this_cpu_ptr(&timer_bases[BASE_STD]);
        u64 expires = KTIME_MAX;
        unsigned long nextevt;
@@ -1376,19 +1505,80 @@ u64 get_next_timer_interrupt(unsigned long basej, u64 basem)
                return expires;
        spin_lock(&base->lock);
-        if (base->active_timers) {
+        nextevt = __next_timer_interrupt(base);
-                if (time_before_eq(base->next_timer, base->timer_jiffies))
+        base->next_expiry = nextevt;
-                        base->next_timer = __next_timer_interrupt(base);
+        /*
-                nextevt = base->next_timer;
+         * We have a fresh next event. Check whether we can forward the base:
-                if (time_before_eq(nextevt, basej))
+         */
-                        expires = basem;
+        if (time_after(nextevt, jiffies))
-                else
+                base->clk = jiffies;
-                        expires = basem + (nextevt - basej) * TICK_NSEC;
+        else if (time_after(nextevt, base->clk))
+                base->clk = nextevt;
+        if (time_before_eq(nextevt, basej)) {
+                expires = basem;
+                base->is_idle = false;
+        } else {
+                expires = basem + (nextevt - basej) * TICK_NSEC;
+                /*
+                 * If we expect to sleep more than a tick, mark the base idle:
+                 */
+                if ((expires - basem) > TICK_NSEC)
+                        base->is_idle = true;
        }
        spin_unlock(&base->lock);
        return cmp_next_hrtimer_event(basem, expires);
 }
+/**
+ * timer_clear_idle - Clear the idle state of the timer base
+ *
+ * Called with interrupts disabled
+ */
+void timer_clear_idle(void)
+{
+        struct timer_base *base = this_cpu_ptr(&timer_bases[BASE_STD]);
+        /*
+         * We do this unlocked. The worst outcome is a remote enqueue sending
+         * a pointless IPI, but taking the lock would just make the window for
+         * sending the IPI a few instructions smaller for the cost of taking
+         * the lock in the exit from idle path.
+         */
+        base->is_idle = false;
+}
+static int collect_expired_timers(struct timer_base *base,
+                                  struct hlist_head *heads)
+{
+        /*
+         * NOHZ optimization. After a long idle sleep we need to forward the
+         * base to current jiffies. Avoid a loop by searching the bitfield for
+         * the next expiring timer.
+         */
+        if ((long)(jiffies - base->clk) > 2) {
+                unsigned long next = __next_timer_interrupt(base);
+                /*
+                 * If the next timer is ahead of time forward to current
+                 * jiffies, otherwise forward to the next expiry time:
+                 */
+                if (time_after(next, jiffies)) {
+                        /* The call site will increment clock! */
+                        base->clk = jiffies - 1;
+                        return 0;
+                }
+                base->clk = next;
+        }
+        return __collect_expired_timers(base, heads);
+}
+#else
+static inline int collect_expired_timers(struct timer_base *base,
+                                         struct hlist_head *heads)
+{
+        return __collect_expired_timers(base, heads);
+}
 #endif
 /*
@@ -1411,15 +1601,42 @@ void update_process_times(int user_tick)
        run_posix_cpu_timers(p);
 }
+/**
+ * __run_timers - run all expired timers (if any) on this CPU.
+ * @base: the timer vector to be processed.
+ */
+static inline void __run_timers(struct timer_base *base)
+{
+        struct hlist_head heads[LVL_DEPTH];
+        int levels;
+        if (!time_after_eq(jiffies, base->clk))
+                return;
+        spin_lock_irq(&base->lock);
+        while (time_after_eq(jiffies, base->clk)) {
+                levels = collect_expired_timers(base, heads);
+                base->clk++;
+                while (levels--)
+                        expire_timers(base, heads + levels);
+        }
+        base->running_timer = NULL;
+        spin_unlock_irq(&base->lock);
+}
 /*
 * This function runs timers and the timer-tq in bottom half context.
 */
 static void run_timer_softirq(struct softirq_action *h)
 {
-        struct tvec_base *base = this_cpu_ptr(&tvec_bases);
+        struct timer_base *base = this_cpu_ptr(&timer_bases[BASE_STD]);
-        if (time_after_eq(jiffies, base->timer_jiffies))
+        __run_timers(base);
-                __run_timers(base);
+        if (IS_ENABLED(CONFIG_NO_HZ_COMMON) && base->nohz_active)
+                __run_timers(this_cpu_ptr(&timer_bases[BASE_DEF]));
 }
 /*
@@ -1427,7 +1644,18 @@ static void run_timer_softirq(struct softirq_action *h)
 */
 void run_local_timers(void)
 {
+        struct timer_base *base = this_cpu_ptr(&timer_bases[BASE_STD]);
        hrtimer_run_queues();
+        /* Raise the softirq only if required. */
+        if (time_before(jiffies, base->clk)) {
+                if (!IS_ENABLED(CONFIG_NO_HZ_COMMON) || !base->nohz_active)
+                        return;
+                /* CPU is awake, so check the deferrable base. */
+                base++;
+                if (time_before(jiffies, base->clk))
+                        return;
+        }
        raise_softirq(TIMER_SOFTIRQ);
 }
@@ -1512,7 +1740,7 @@ signed long __sched schedule_timeout(signed long timeout)
        expire = timeout + jiffies;
        setup_timer_on_stack(&timer, process_timeout, (unsigned long)current);
-        __mod_timer(&timer, expire, false, TIMER_NOT_PINNED);
+        __mod_timer(&timer, expire, false);
        schedule();
        del_singleshot_timer_sync(&timer);
@@ -1563,14 +1791,13 @@ signed long __sched schedule_timeout_idle(signed long timeout)
 EXPORT_SYMBOL(schedule_timeout_idle);
 #ifdef CONFIG_HOTPLUG_CPU
-static void migrate_timer_list(struct tvec_base *new_base, struct hlist_head *head)
+static void migrate_timer_list(struct timer_base *new_base, struct hlist_head *head)
 {
        struct timer_list *timer;
        int cpu = new_base->cpu;
        while (!hlist_empty(head)) {
                timer = hlist_entry(head->first, struct timer_list, entry);
-                /* We ignore the accounting on the dying cpu */
                detach_timer(timer, false);
                timer->flags = (timer->flags & ~TIMER_BASEMASK) | cpu;
                internal_add_timer(new_base, timer);
@@ -1579,37 +1806,31 @@ static void migrate_timer_list(struct tvec_base *new_base, struct hlist_head *he
 static void migrate_timers(int cpu)
 {
-        struct tvec_base *old_base;
+        struct timer_base *old_base;
-        struct tvec_base *new_base;
+        struct timer_base *new_base;
-        int i;
+        int b, i;
        BUG_ON(cpu_online(cpu));
-        old_base = per_cpu_ptr(&tvec_bases, cpu);
-        new_base = get_cpu_ptr(&tvec_bases);
-        /*
-         * The caller is globally serialized and nobody else
-         * takes two locks at once, deadlock is not possible.
-         */
-        spin_lock_irq(&new_base->lock);
-        spin_lock_nested(&old_base->lock, SINGLE_DEPTH_NESTING);
-        BUG_ON(old_base->running_timer);
-        for (i = 0; i < TVR_SIZE; i++)
-                migrate_timer_list(new_base, old_base->tv1.vec + i);
-        for (i = 0; i < TVN_SIZE; i++) {
-                migrate_timer_list(new_base, old_base->tv2.vec + i);
-                migrate_timer_list(new_base, old_base->tv3.vec + i);
-                migrate_timer_list(new_base, old_base->tv4.vec + i);
-                migrate_timer_list(new_base, old_base->tv5.vec + i);
-        }
-        old_base->active_timers = 0;
+        for (b = 0; b < NR_BASES; b++) {
-        old_base->all_timers = 0;
+                old_base = per_cpu_ptr(&timer_bases[b], cpu);
+                new_base = get_cpu_ptr(&timer_bases[b]);
+                /*
+                 * The caller is globally serialized and nobody else
+                 * takes two locks at once, deadlock is not possible.
+                 */
+                spin_lock_irq(&new_base->lock);
+                spin_lock_nested(&old_base->lock, SINGLE_DEPTH_NESTING);
+                BUG_ON(old_base->running_timer);
-        spin_unlock(&old_base->lock);
+                for (i = 0; i < WHEEL_SIZE; i++)
-        spin_unlock_irq(&new_base->lock);
+                        migrate_timer_list(new_base, old_base->vectors + i);
-        put_cpu_ptr(&tvec_bases);
+                spin_unlock(&old_base->lock);
+                spin_unlock_irq(&new_base->lock);
+                put_cpu_ptr(&timer_bases);
+        }
 }
 static int timer_cpu_notify(struct notifier_block *self,
@@ -1637,13 +1858,15 @@ static inline void timer_register_cpu_notifier(void) { }
 static void __init init_timer_cpu(int cpu)
 {
-        struct tvec_base *base = per_cpu_ptr(&tvec_bases, cpu);
+        struct timer_base *base;
+        int i;
-        base->cpu = cpu;
-        spin_lock_init(&base->lock);
-        base->timer_jiffies = jiffies;
+        for (i = 0; i < NR_BASES; i++) {
-        base->next_timer = base->timer_jiffies;
+                base = per_cpu_ptr(&timer_bases[i], cpu);
+                base->cpu = cpu;
+                spin_lock_init(&base->lock);
+                base->clk = jiffies;
+        }
 }
 static void __init init_timer_cpus(void)
@@ -1702,9 +1925,15 @@ static void __sched do_usleep_range(unsigned long min, unsigned long max)
 }
 /**
- * usleep_range - Drop in replacement for udelay where wakeup is flexible
+ * usleep_range - Sleep for an approximate time
 * @min: Minimum time in usecs to sleep
 * @max: Maximum time in usecs to sleep
+ *
+ * In non-atomic context where the exact wakeup time is flexible, use
+ * usleep_range() instead of udelay().  The sleep improves responsiveness
+ * by avoiding the CPU-hogging busy-wait of udelay(), and the range reduces
+ * power usage by allowing hrtimers to take advantage of an already-
+ * scheduled interrupt instead of scheduling a new one just for this sleep.
 */
 void __sched usleep_range(unsigned long min, unsigned long max)
 {
diff --git a/kernel/time/timer_stats.c b/kernel/time/timer_stats.c
index 1adecb4b87c8..087204c733eb 100644
--- a/kernel/time/timer_stats.c
+++ b/kernel/time/timer_stats.c
@@ -279,7 +279,7 @@ static void print_name_offset(struct seq_file *m, unsigned long addr)
 static int tstats_show(struct seq_file *m, void *v)
 {
-        struct timespec period;
+        struct timespec64 period;
        struct entry *entry;
        unsigned long ms;
        long events = 0;
@@ -295,11 +295,11 @@ static int tstats_show(struct seq_file *m, void *v)
        time = ktime_sub(time_stop, time_start);
-        period = ktime_to_timespec(time);
+        period = ktime_to_timespec64(time);
        ms = period.tv_nsec / 1000000;
        seq_puts(m, "Timer Stats Version: v0.3\n");
-        seq_printf(m, "Sample period: %ld.%03ld s\n", period.tv_sec, ms);
+        seq_printf(m, "Sample period: %ld.%03ld s\n", (long)period.tv_sec, ms);
        if (atomic_read(&overflow_count))
                seq_printf(m, "Overflow: %d entries\n", atomic_read(&overflow_count));
        seq_printf(m, "Collection: %s\n", timer_stats_active ? "active" : "inactive");
diff --git a/lib/random32.c b/lib/random32.c
index 510d1ce7d4d2..69ed593aab07 100644
--- a/lib/random32.c
+++ b/lib/random32.c
@@ -233,7 +233,6 @@ static void __prandom_timer(unsigned long dontcare)
 static void __init __prandom_start_seed_timer(void)
 {
-        set_timer_slack(&seed_timer, HZ);
        seed_timer.expires = jiffies + msecs_to_jiffies(40 * MSEC_PER_SEC);
        add_timer(&seed_timer);
 }
diff --git a/net/ipv4/inet_connection_sock.c b/net/ipv4/inet_connection_sock.c
index fa8c39804bdb..61a9deec2993 100644
--- a/net/ipv4/inet_connection_sock.c
+++ b/net/ipv4/inet_connection_sock.c
@@ -603,7 +603,7 @@ static void reqsk_timer_handler(unsigned long data)
                if (req->num_timeout++ == 0)
                        atomic_dec(&queue->young);
                timeo = min(TCP_TIMEOUT_INIT << req->num_timeout, TCP_RTO_MAX);
-                mod_timer_pinned(&req->rsk_timer, jiffies + timeo);
+                mod_timer(&req->rsk_timer, jiffies + timeo);
                return;
        }
 drop:
@@ -617,8 +617,9 @@ static void reqsk_queue_hash_req(struct request_sock *req,
        req->num_timeout = 0;
        req->sk = NULL;
-        setup_timer(&req->rsk_timer, reqsk_timer_handler, (unsigned long)req);
+        setup_pinned_timer(&req->rsk_timer, reqsk_timer_handler,
-        mod_timer_pinned(&req->rsk_timer, jiffies + timeout);
+                            (unsigned long)req);
+        mod_timer(&req->rsk_timer, jiffies + timeout);
        inet_ehash_insert(req_to_sk(req), NULL);
        /* before letting lookups find us, make sure all req fields
diff --git a/net/ipv4/inet_timewait_sock.c b/net/ipv4/inet_timewait_sock.c
index 206581674806..ddcd56c08d14 100644
--- a/net/ipv4/inet_timewait_sock.c
+++ b/net/ipv4/inet_timewait_sock.c
@@ -188,7 +188,8 @@ struct inet_timewait_sock *inet_twsk_alloc(const struct sock *sk,
                tw->tw_prot         = sk->sk_prot_creator;
                atomic64_set(&tw->tw_cookie, atomic64_read(&sk->sk_cookie));
                twsk_net_set(tw, sock_net(sk));
-                setup_timer(&tw->tw_timer, tw_timer_handler, (unsigned long)tw);
+                setup_pinned_timer(&tw->tw_timer, tw_timer_handler,
+                                   (unsigned long)tw);
                /*
                 * Because we use RCU lookups, we should not set tw_refcnt
                 * to a non null value before everything is setup for this
@@ -248,7 +249,7 @@ void __inet_twsk_schedule(struct inet_timewait_sock *tw, int timeo, bool rearm)
        tw->tw_kill = timeo <= 4*HZ;
        if (!rearm) {
-                BUG_ON(mod_timer_pinned(&tw->tw_timer, jiffies + timeo));
+                BUG_ON(mod_timer(&tw->tw_timer, jiffies + timeo));
                atomic_inc(&tw->tw_dr->tw_count);
        } else {
                mod_timer_pending(&tw->tw_timer, jiffies + timeo);