Merge branch 'fortglx/3.12/time' into fortglx/3.13/time

Merge in the timekeeping changes that missed 3.12

Signed-off-by: John Stultz <john.stultz@linaro.org>

diff --combined kernel/time/clocksource.c
index 637a14af6c21ec32655bf7c1f84e55c411dcafb6,a2e72b8d28d089fa433708620c81957764e4639c..64cf63ca09cc58be75bcba8dd03f6133705d94fc
--- 1/kernel/time/clocksource.c
--- 2/kernel/time/clocksource.c
+++ b/kernel/time/clocksource.c
@@@ -479,6 -479,7 +479,7 @@@ static inline void clocksource_dequeue_
  static inline void clocksource_resume_watchdog(void) { }
  static inline int __clocksource_watchdog_kthread(void) { return 0; }
  static bool clocksource_is_watchdog(struct clocksource *cs) { return false; }
+ void clocksource_mark_unstable(struct clocksource *cs) { }
  
  #endif /* CONFIG_CLOCKSOURCE_WATCHDOG */
  
@@@ -537,55 -538,40 +538,55 @@@ static u32 clocksource_max_adjustment(s
  }
  
  /**
 - * clocksource_max_deferment - Returns max time the clocksource can be deferred
 - * @cs:         Pointer to clocksource
 - *
 + * clocks_calc_max_nsecs - Returns maximum nanoseconds that can be converted
 + * @mult:     cycle to nanosecond multiplier
 + * @shift:    cycle to nanosecond divisor (power of two)
 + * @maxadj:   maximum adjustment value to mult (~11%)
 + * @mask:     bitmask for two's complement subtraction of non 64 bit counters
   */
 -static u64 clocksource_max_deferment(struct clocksource *cs)
 +u64 clocks_calc_max_nsecs(u32 mult, u32 shift, u32 maxadj, u64 mask)
  {
        u64 max_nsecs, max_cycles;
  
        /*
         * Calculate the maximum number of cycles that we can pass to the
         * cyc2ns function without overflowing a 64-bit signed result. The
 -       * maximum number of cycles is equal to ULLONG_MAX/(cs->mult+cs->maxadj)
 +       * maximum number of cycles is equal to ULLONG_MAX/(mult+maxadj)
         * which is equivalent to the below.
 -       * max_cycles < (2^63)/(cs->mult + cs->maxadj)
 -       * max_cycles < 2^(log2((2^63)/(cs->mult + cs->maxadj)))
 -       * max_cycles < 2^(log2(2^63) - log2(cs->mult + cs->maxadj))
 -       * max_cycles < 2^(63 - log2(cs->mult + cs->maxadj))
 -       * max_cycles < 1 << (63 - log2(cs->mult + cs->maxadj))
 +       * max_cycles < (2^63)/(mult + maxadj)
 +       * max_cycles < 2^(log2((2^63)/(mult + maxadj)))
 +       * max_cycles < 2^(log2(2^63) - log2(mult + maxadj))
 +       * max_cycles < 2^(63 - log2(mult + maxadj))
 +       * max_cycles < 1 << (63 - log2(mult + maxadj))
         * Please note that we add 1 to the result of the log2 to account for
         * any rounding errors, ensure the above inequality is satisfied and
         * no overflow will occur.
         */
 -      max_cycles = 1ULL << (63 - (ilog2(cs->mult + cs->maxadj) + 1));
 +      max_cycles = 1ULL << (63 - (ilog2(mult + maxadj) + 1));
  
        /*
         * The actual maximum number of cycles we can defer the clocksource is
 -       * determined by the minimum of max_cycles and cs->mask.
 +       * determined by the minimum of max_cycles and mask.
         * Note: Here we subtract the maxadj to make sure we don't sleep for
         * too long if there's a large negative adjustment.
         */
 -      max_cycles = min_t(u64, max_cycles, (u64) cs->mask);
 -      max_nsecs = clocksource_cyc2ns(max_cycles, cs->mult - cs->maxadj,
 -                                      cs->shift);
 +      max_cycles = min(max_cycles, mask);
 +      max_nsecs = clocksource_cyc2ns(max_cycles, mult - maxadj, shift);
 +
 +      return max_nsecs;
 +}
 +
 +/**
 + * clocksource_max_deferment - Returns max time the clocksource can be deferred
 + * @cs:         Pointer to clocksource
 + *
 + */
 +static u64 clocksource_max_deferment(struct clocksource *cs)
 +{
 +      u64 max_nsecs;
  
 +      max_nsecs = clocks_calc_max_nsecs(cs->mult, cs->shift, cs->maxadj,
 +                                        cs->mask);
        /*
         * To ensure that the clocksource does not wrap whilst we are idle,
         * limit the time the clocksource can be deferred by 12.5%. Please