reverted patches to rt timer code

diff --git a/include/linux/hrtimer.h b/include/linux/hrtimer.h
index bdbf77db..79a7a35 100644
--- a/include/linux/hrtimer.h
+++ b/include/linux/hrtimer.h
@@ -461,8 +461,9 @@ extern int schedule_hrtimeout_range_clock(ktime_t *expires,
        unsigned long delta, const enum hrtimer_mode mode, int clock);
 extern int schedule_hrtimeout(ktime_t *expires, const enum hrtimer_mode mode);

-/* Called from the periodic timer tick */
+/* Soft interrupt function to run the hrtimer queues: */
 extern void hrtimer_run_queues(void);
+extern void hrtimer_run_pending(void);

 /* Bootup initialization: */
 extern void __init hrtimers_init(void);
diff --git a/kernel/hrtimer.c b/kernel/hrtimer.c
index c19183d..c6d8232 100644
--- a/kernel/hrtimer.c
+++ b/kernel/hrtimer.c
@@ -1694,6 +1694,30 @@ static void run_hrtimer_softirq(struct softirq_action *h)
 }

 /*
+ * Called from timer softirq every jiffy, expire hrtimers:
+ *
+ * For HRT its the fall back code to run the softirq in the timer
+ * softirq context in case the hrtimer initialization failed or has
+ * not been done yet.
+ */
+void hrtimer_run_pending(void)
+{
+   if (hrtimer_hres_active())
+       return;
+
+   /*
+    * This _is_ ugly: We have to check in the softirq context,
+    * whether we can switch to highres and / or nohz mode. The
+    * clocksource switch happens in the timer interrupt with
+    * xtime_lock held. Notification from there only sets the
+    * check bit in the tick_oneshot code, otherwise we might
+    * deadlock vs. xtime_lock.
+    */
+   if (tick_check_oneshot_change(!hrtimer_is_hres_enabled()))
+       hrtimer_switch_to_hres();
+}
+
+/*
  * Called from hardirq context every jiffy
  */
 void hrtimer_run_queues(void)
@@ -1706,13 +1730,6 @@ void hrtimer_run_queues(void)
    if (hrtimer_hres_active())
        return;

-   /*
-    * Check whether we can switch to highres mode.
-    */
-   if (tick_check_oneshot_change(!hrtimer_is_hres_enabled())
-       && hrtimer_switch_to_hres())
-       return;
-
    for (index = 0; index < HRTIMER_MAX_CLOCK_BASES; index++) {
        base = &cpu_base->clock_base[index];
        if (!timerqueue_getnext(&base->active))
diff --git a/kernel/timer.c b/kernel/timer.c
index cc34e42..835b608 100644
--- a/kernel/timer.c
+++ b/kernel/timer.c
@@ -1400,7 +1400,7 @@ unsigned long get_next_timer_interrupt(unsigned long now)
        expires = base->next_timer;
    }
 #ifdef CONFIG_PREEMPT_RT_FULL
-   rt_spin_unlock_after_trylock_in_irq(&base->lock);
+   rt_spin_unlock(&base->lock);
 #else
    spin_unlock(&base->lock);
 #endif
@@ -1443,6 +1443,8 @@ static void run_timer_softirq(struct softirq_action *h)
    irq_work_run();
 #endif

+   hrtimer_run_pending();
+
    if (time_after_eq(jiffies, base->timer_jiffies))
        __run_timers(base);
 }
@@ -1452,39 +1454,8 @@ static void run_timer_softirq(struct softirq_action *h)
  */
 void run_local_timers(void)
 {
-   struct tvec_base *base = __this_cpu_read(tvec_bases);
-
    hrtimer_run_queues();
-   /*
-    * We can access this lockless as we are in the timer
-    * interrupt. If there are no timers queued, nothing to do in
-    * the timer softirq.
-    */
-#ifdef CONFIG_PREEMPT_RT_FULL
-   /* On RT, irq work runs from softirq */
-   if (irq_work_needs_cpu()) {
-       raise_softirq(TIMER_SOFTIRQ);
-       return;
-   }
-
-   if (!spin_do_trylock(&base->lock)) {
-       raise_softirq(TIMER_SOFTIRQ);
-       return;
-   }
-#endif
-
-   if (!base->active_timers)
-       goto out;
-
-   /* Check whether the next pending timer has expired */
-   if (time_before_eq(base->next_timer, jiffies))
-       raise_softirq(TIMER_SOFTIRQ);
-out:
-#ifdef CONFIG_PREEMPT_RT_FULL
-   rt_spin_unlock_after_trylock_in_irq(&base->lock);
-#endif
-   /* The ; ensures that gcc won't complain in the !RT case */
-   ;
+   raise_softirq(TIMER_SOFTIRQ);
 }

 #ifdef __ARCH_WANT_SYS_ALARM