2 files changed, 15 insertions, 15 deletions

diff --git a/kernel/time/ntp.c b/kernel/time/ntp.c
index 10fe17df45a0..a8fd1ba1ef19 100644
--- a/kernel/time/ntp.c
+++ b/kernel/time/ntp.c
@@ -27,7 +27,7 @@ static u64 tick_length, tick_length_base;
 
 #define MAX_TICKADJ             500             /* microsecs */
 #define MAX_TICKADJ_SCALED      (((u64)(MAX_TICKADJ * NSEC_PER_USEC) << \
-                                  TICK_LENGTH_SHIFT) / NTP_INTERVAL_FREQ)
+                                  NTP_SCALE_SHIFT) / NTP_INTERVAL_FREQ)
 
 /*
  * phase-lock loop variables
@@ -48,13 +48,13 @@ static long ntp_tick_adj;
 static void ntp_update_frequency(void)
 {
         u64 second_length = (u64)(tick_usec * NSEC_PER_USEC * USER_HZ)
-                                << TICK_LENGTH_SHIFT;
-        second_length += (s64)ntp_tick_adj << TICK_LENGTH_SHIFT;
+                                << NTP_SCALE_SHIFT;
+        second_length += (s64)ntp_tick_adj << NTP_SCALE_SHIFT;
         second_length += time_freq;
 
         tick_length_base = second_length;
 
-        tick_nsec = div_u64(second_length, HZ) >> TICK_LENGTH_SHIFT;
+        tick_nsec = div_u64(second_length, HZ) >> NTP_SCALE_SHIFT;
         tick_length_base = div_u64(tick_length_base, NTP_INTERVAL_FREQ);
 }
 
@@ -86,10 +86,10 @@ static void ntp_update_offset(long offset)
         time_reftime = xtime.tv_sec;
 
         freq_adj = (s64)offset * mtemp;
-        freq_adj <<= TICK_LENGTH_SHIFT - 2 * (SHIFT_PLL + 2 + time_constant);
+        freq_adj <<= NTP_SCALE_SHIFT - 2 * (SHIFT_PLL + 2 + time_constant);
         time_status &= ~STA_MODE;
         if (mtemp >= MINSEC && (time_status & STA_FLL || mtemp > MAXSEC)) {
-                freq_adj += div_s64((s64)offset << (TICK_LENGTH_SHIFT - SHIFT_FLL),
+                freq_adj += div_s64((s64)offset << (NTP_SCALE_SHIFT - SHIFT_FLL),
                                     mtemp);
                 time_status |= STA_MODE;
         }
@@ -97,7 +97,7 @@ static void ntp_update_offset(long offset)
         freq_adj = min(freq_adj, MAXFREQ_SCALED);
         time_freq = max(freq_adj, -MAXFREQ_SCALED);
 
-        time_offset = div_s64((s64)offset << TICK_LENGTH_SHIFT, NTP_INTERVAL_FREQ);
+        time_offset = div_s64((s64)offset << NTP_SCALE_SHIFT, NTP_INTERVAL_FREQ);
 }
 
 /**
@@ -197,7 +197,7 @@ void second_overflow(void)
                         tick_length -= MAX_TICKADJ_SCALED;
                 } else {
                         tick_length += (s64)(time_adjust * NSEC_PER_USEC /
-                                        NTP_INTERVAL_FREQ) << TICK_LENGTH_SHIFT;
+                                        NTP_INTERVAL_FREQ) << NTP_SCALE_SHIFT;
                         time_adjust = 0;
                 }
         }
@@ -369,13 +369,13 @@ int do_adjtimex(struct timex *txc)
                 txc->offset = save_adjust;
         else {
                 txc->offset = shift_right(time_offset * NTP_INTERVAL_FREQ,
-                                          TICK_LENGTH_SHIFT);
+                                          NTP_SCALE_SHIFT);
                 if (!(time_status & STA_NANO))
                         txc->offset /= NSEC_PER_USEC;
         }
         txc->freq          = shift_right((s32)(time_freq >> PPM_SCALE_INV_SHIFT) *
                                          (s64)PPM_SCALE_INV,
-                                         TICK_LENGTH_SHIFT);
+                                         NTP_SCALE_SHIFT);
         txc->maxerror      = time_maxerror;
         txc->esterror      = time_esterror;
         txc->status        = time_status;
diff --git a/kernel/time/timekeeping.c b/kernel/time/timekeeping.c
index 2d6087c7cf98..a26429bc772a 100644
--- a/kernel/time/timekeeping.c
+++ b/kernel/time/timekeeping.c
@@ -371,7 +371,7 @@ static __always_inline int clocksource_bigadjust(s64 error, s64 *interval,
          * here.  This is tuned so that an error of about 1 msec is adjusted
          * within about 1 sec (or 2^20 nsec in 2^SHIFT_HZ ticks).
          */
-        error2 = clock->error >> (TICK_LENGTH_SHIFT + 22 - 2 * SHIFT_HZ);
+        error2 = clock->error >> (NTP_SCALE_SHIFT + 22 - 2 * SHIFT_HZ);
         error2 = abs(error2);
         for (look_ahead = 0; error2 > 0; look_ahead++)
                 error2 >>= 2;
@@ -381,7 +381,7 @@ static __always_inline int clocksource_bigadjust(s64 error, s64 *interval,
          * remove the single look ahead already included in the error.
          */
         tick_error = current_tick_length() >>
-                (TICK_LENGTH_SHIFT - clock->shift + 1);
+                (NTP_SCALE_SHIFT - clock->shift + 1);
         tick_error -= clock->xtime_interval >> 1;
         error = ((error - tick_error) >> look_ahead) + tick_error;
 
@@ -412,7 +412,7 @@ static void clocksource_adjust(s64 offset)
         s64 error, interval = clock->cycle_interval;
         int adj;
 
-        error = clock->error >> (TICK_LENGTH_SHIFT - clock->shift - 1);
+        error = clock->error >> (NTP_SCALE_SHIFT - clock->shift - 1);
         if (error > interval) {
                 error >>= 2;
                 if (likely(error <= interval))
@@ -434,7 +434,7 @@ static void clocksource_adjust(s64 offset)
         clock->xtime_interval += interval;
         clock->xtime_nsec -= offset;
         clock->error -= (interval - offset) <<
-                        (TICK_LENGTH_SHIFT - clock->shift);
+                        (NTP_SCALE_SHIFT - clock->shift);
 }
 
 /**
@@ -474,7 +474,7 @@ void update_wall_time(void)
 
                 /* accumulate error between NTP and clock interval */
                 clock->error += current_tick_length();
-                clock->error -= clock->xtime_interval << (TICK_LENGTH_SHIFT - clock->shift);
+                clock->error -= clock->xtime_interval << (NTP_SCALE_SHIFT - clock->shift);
         }
 
         /* correct the clock when NTP error is too big */