john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 1 | /* |
| 2 | * linux/kernel/time/ntp.c |
| 3 | * |
| 4 | * NTP state machine interfaces and logic. |
| 5 | * |
| 6 | * This code was mainly moved from kernel/timer.c and kernel/time.c |
| 7 | * Please see those files for relevant copyright info and historical |
| 8 | * changelogs. |
| 9 | */ |
| 10 | |
| 11 | #include <linux/mm.h> |
| 12 | #include <linux/time.h> |
Thomas Gleixner | 8264445 | 2007-07-21 04:37:37 -0700 | [diff] [blame] | 13 | #include <linux/timer.h> |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 14 | #include <linux/timex.h> |
Alexey Dobriyan | e8edc6e | 2007-05-21 01:22:52 +0400 | [diff] [blame] | 15 | #include <linux/jiffies.h> |
| 16 | #include <linux/hrtimer.h> |
Alexey Dobriyan | aa0ac36 | 2007-07-15 23:40:39 -0700 | [diff] [blame] | 17 | #include <linux/capability.h> |
Roman Zippel | 71abb3a | 2008-05-01 04:34:26 -0700 | [diff] [blame] | 18 | #include <linux/math64.h> |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 19 | #include <asm/timex.h> |
| 20 | |
Roman Zippel | b0ee755 | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 21 | /* |
| 22 | * Timekeeping variables |
| 23 | */ |
| 24 | unsigned long tick_usec = TICK_USEC; /* USER_HZ period (usec) */ |
| 25 | unsigned long tick_nsec; /* ACTHZ period (nsec) */ |
| 26 | static u64 tick_length, tick_length_base; |
| 27 | |
Roman Zippel | 8f807f8 | 2006-09-30 23:28:25 -0700 | [diff] [blame] | 28 | #define MAX_TICKADJ 500 /* microsecs */ |
| 29 | #define MAX_TICKADJ_SCALED (((u64)(MAX_TICKADJ * NSEC_PER_USEC) << \ |
john stultz | f4304ab | 2007-02-16 01:27:26 -0800 | [diff] [blame] | 30 | TICK_LENGTH_SHIFT) / NTP_INTERVAL_FREQ) |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 31 | |
| 32 | /* |
| 33 | * phase-lock loop variables |
| 34 | */ |
| 35 | /* TIME_ERROR prevents overwriting the CMOS clock */ |
Adrian Bunk | 70bc42f | 2006-09-30 23:28:29 -0700 | [diff] [blame] | 36 | static int time_state = TIME_OK; /* clock synchronization status */ |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 37 | int time_status = STA_UNSYNC; /* clock status bits */ |
Roman Zippel | ee9851b | 2008-05-01 04:34:32 -0700 | [diff] [blame] | 38 | static s64 time_offset; /* time adjustment (ns) */ |
Adrian Bunk | 70bc42f | 2006-09-30 23:28:29 -0700 | [diff] [blame] | 39 | static long time_constant = 2; /* pll time constant */ |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 40 | long time_maxerror = NTP_PHASE_LIMIT; /* maximum error (us) */ |
| 41 | long time_esterror = NTP_PHASE_LIMIT; /* estimated error (us) */ |
Roman Zippel | dc6a43e | 2006-09-30 23:28:24 -0700 | [diff] [blame] | 42 | long time_freq; /* frequency offset (scaled ppm)*/ |
Adrian Bunk | 70bc42f | 2006-09-30 23:28:29 -0700 | [diff] [blame] | 43 | static long time_reftime; /* time at last adjustment (s) */ |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 44 | long time_adjust; |
Roman Zippel | 10a398d | 2008-03-04 15:14:26 -0800 | [diff] [blame] | 45 | static long ntp_tick_adj; |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 46 | |
Adrian Bunk | 70bc42f | 2006-09-30 23:28:29 -0700 | [diff] [blame] | 47 | static void ntp_update_frequency(void) |
| 48 | { |
john stultz | f4304ab | 2007-02-16 01:27:26 -0800 | [diff] [blame] | 49 | u64 second_length = (u64)(tick_usec * NSEC_PER_USEC * USER_HZ) |
| 50 | << TICK_LENGTH_SHIFT; |
Roman Zippel | 10a398d | 2008-03-04 15:14:26 -0800 | [diff] [blame] | 51 | second_length += (s64)ntp_tick_adj << TICK_LENGTH_SHIFT; |
john stultz | f4304ab | 2007-02-16 01:27:26 -0800 | [diff] [blame] | 52 | second_length += (s64)time_freq << (TICK_LENGTH_SHIFT - SHIFT_NSEC); |
Adrian Bunk | 70bc42f | 2006-09-30 23:28:29 -0700 | [diff] [blame] | 53 | |
john stultz | f4304ab | 2007-02-16 01:27:26 -0800 | [diff] [blame] | 54 | tick_length_base = second_length; |
Adrian Bunk | 70bc42f | 2006-09-30 23:28:29 -0700 | [diff] [blame] | 55 | |
Roman Zippel | 71abb3a | 2008-05-01 04:34:26 -0700 | [diff] [blame] | 56 | tick_nsec = div_u64(second_length, HZ) >> TICK_LENGTH_SHIFT; |
| 57 | tick_length_base = div_u64(tick_length_base, NTP_INTERVAL_FREQ); |
Adrian Bunk | 70bc42f | 2006-09-30 23:28:29 -0700 | [diff] [blame] | 58 | } |
| 59 | |
Roman Zippel | ee9851b | 2008-05-01 04:34:32 -0700 | [diff] [blame] | 60 | static void ntp_update_offset(long offset) |
| 61 | { |
| 62 | long mtemp; |
| 63 | s64 freq_adj; |
| 64 | |
| 65 | if (!(time_status & STA_PLL)) |
| 66 | return; |
| 67 | |
Roman Zippel | eea83d8 | 2008-05-01 04:34:33 -0700 | [diff] [blame^] | 68 | time_offset = offset; |
| 69 | if (!(time_status & STA_NANO)) |
| 70 | time_offset *= NSEC_PER_USEC; |
Roman Zippel | ee9851b | 2008-05-01 04:34:32 -0700 | [diff] [blame] | 71 | |
| 72 | /* |
| 73 | * Scale the phase adjustment and |
| 74 | * clamp to the operating range. |
| 75 | */ |
| 76 | time_offset = min(time_offset, (s64)MAXPHASE * NSEC_PER_USEC); |
| 77 | time_offset = max(time_offset, (s64)-MAXPHASE * NSEC_PER_USEC); |
| 78 | |
| 79 | /* |
| 80 | * Select how the frequency is to be controlled |
| 81 | * and in which mode (PLL or FLL). |
| 82 | */ |
| 83 | if (time_status & STA_FREQHOLD || time_reftime == 0) |
| 84 | time_reftime = xtime.tv_sec; |
| 85 | mtemp = xtime.tv_sec - time_reftime; |
| 86 | time_reftime = xtime.tv_sec; |
| 87 | |
| 88 | freq_adj = time_offset * mtemp; |
| 89 | freq_adj = shift_right(freq_adj, time_constant * 2 + |
| 90 | (SHIFT_PLL + 2) * 2 - SHIFT_NSEC); |
Roman Zippel | eea83d8 | 2008-05-01 04:34:33 -0700 | [diff] [blame^] | 91 | time_status &= ~STA_MODE; |
| 92 | if (mtemp >= MINSEC && (time_status & STA_FLL || mtemp > MAXSEC)) { |
Roman Zippel | ee9851b | 2008-05-01 04:34:32 -0700 | [diff] [blame] | 93 | freq_adj += div_s64(time_offset << (SHIFT_NSEC - SHIFT_FLL), mtemp); |
Roman Zippel | eea83d8 | 2008-05-01 04:34:33 -0700 | [diff] [blame^] | 94 | time_status |= STA_MODE; |
| 95 | } |
Roman Zippel | ee9851b | 2008-05-01 04:34:32 -0700 | [diff] [blame] | 96 | freq_adj += time_freq; |
| 97 | freq_adj = min(freq_adj, (s64)MAXFREQ_NSEC); |
| 98 | time_freq = max(freq_adj, (s64)-MAXFREQ_NSEC); |
| 99 | time_offset = div_s64(time_offset, NTP_INTERVAL_FREQ); |
| 100 | time_offset <<= SHIFT_UPDATE; |
| 101 | } |
| 102 | |
Roman Zippel | b0ee755 | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 103 | /** |
| 104 | * ntp_clear - Clears the NTP state variables |
| 105 | * |
| 106 | * Must be called while holding a write on the xtime_lock |
| 107 | */ |
| 108 | void ntp_clear(void) |
| 109 | { |
| 110 | time_adjust = 0; /* stop active adjtime() */ |
| 111 | time_status |= STA_UNSYNC; |
| 112 | time_maxerror = NTP_PHASE_LIMIT; |
| 113 | time_esterror = NTP_PHASE_LIMIT; |
| 114 | |
| 115 | ntp_update_frequency(); |
| 116 | |
| 117 | tick_length = tick_length_base; |
Roman Zippel | 3d3675c | 2006-09-30 23:28:25 -0700 | [diff] [blame] | 118 | time_offset = 0; |
Roman Zippel | b0ee755 | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 119 | } |
| 120 | |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 121 | /* |
| 122 | * this routine handles the overflow of the microsecond field |
| 123 | * |
| 124 | * The tricky bits of code to handle the accurate clock support |
| 125 | * were provided by Dave Mills (Mills@UDEL.EDU) of NTP fame. |
| 126 | * They were originally developed for SUN and DEC kernels. |
| 127 | * All the kudos should go to Dave for this stuff. |
| 128 | */ |
| 129 | void second_overflow(void) |
| 130 | { |
Roman Zippel | 3d3675c | 2006-09-30 23:28:25 -0700 | [diff] [blame] | 131 | long time_adj; |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 132 | |
| 133 | /* Bump the maxerror field */ |
Roman Zippel | 97eebe1 | 2006-09-30 23:28:26 -0700 | [diff] [blame] | 134 | time_maxerror += MAXFREQ >> SHIFT_USEC; |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 135 | if (time_maxerror > NTP_PHASE_LIMIT) { |
| 136 | time_maxerror = NTP_PHASE_LIMIT; |
| 137 | time_status |= STA_UNSYNC; |
| 138 | } |
| 139 | |
| 140 | /* |
| 141 | * Leap second processing. If in leap-insert state at the end of the |
| 142 | * day, the system clock is set back one second; if in leap-delete |
| 143 | * state, the system clock is set ahead one second. The microtime() |
| 144 | * routine or external clock driver will insure that reported time is |
| 145 | * always monotonic. The ugly divides should be replaced. |
| 146 | */ |
| 147 | switch (time_state) { |
| 148 | case TIME_OK: |
| 149 | if (time_status & STA_INS) |
| 150 | time_state = TIME_INS; |
| 151 | else if (time_status & STA_DEL) |
| 152 | time_state = TIME_DEL; |
| 153 | break; |
| 154 | case TIME_INS: |
| 155 | if (xtime.tv_sec % 86400 == 0) { |
| 156 | xtime.tv_sec--; |
| 157 | wall_to_monotonic.tv_sec++; |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 158 | time_state = TIME_OOP; |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 159 | printk(KERN_NOTICE "Clock: inserting leap second " |
| 160 | "23:59:60 UTC\n"); |
| 161 | } |
| 162 | break; |
| 163 | case TIME_DEL: |
| 164 | if ((xtime.tv_sec + 1) % 86400 == 0) { |
| 165 | xtime.tv_sec++; |
| 166 | wall_to_monotonic.tv_sec--; |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 167 | time_state = TIME_WAIT; |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 168 | printk(KERN_NOTICE "Clock: deleting leap second " |
| 169 | "23:59:59 UTC\n"); |
| 170 | } |
| 171 | break; |
| 172 | case TIME_OOP: |
| 173 | time_state = TIME_WAIT; |
| 174 | break; |
| 175 | case TIME_WAIT: |
| 176 | if (!(time_status & (STA_INS | STA_DEL))) |
Roman Zippel | ee9851b | 2008-05-01 04:34:32 -0700 | [diff] [blame] | 177 | time_state = TIME_OK; |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 178 | } |
| 179 | |
| 180 | /* |
Roman Zippel | f199239 | 2006-09-30 23:28:28 -0700 | [diff] [blame] | 181 | * Compute the phase adjustment for the next second. The offset is |
| 182 | * reduced by a fixed factor times the time constant. |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 183 | */ |
Roman Zippel | b0ee755 | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 184 | tick_length = tick_length_base; |
Roman Zippel | f199239 | 2006-09-30 23:28:28 -0700 | [diff] [blame] | 185 | time_adj = shift_right(time_offset, SHIFT_PLL + time_constant); |
Roman Zippel | 3d3675c | 2006-09-30 23:28:25 -0700 | [diff] [blame] | 186 | time_offset -= time_adj; |
| 187 | tick_length += (s64)time_adj << (TICK_LENGTH_SHIFT - SHIFT_UPDATE); |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 188 | |
Roman Zippel | 8f807f8 | 2006-09-30 23:28:25 -0700 | [diff] [blame] | 189 | if (unlikely(time_adjust)) { |
| 190 | if (time_adjust > MAX_TICKADJ) { |
| 191 | time_adjust -= MAX_TICKADJ; |
| 192 | tick_length += MAX_TICKADJ_SCALED; |
| 193 | } else if (time_adjust < -MAX_TICKADJ) { |
| 194 | time_adjust += MAX_TICKADJ; |
| 195 | tick_length -= MAX_TICKADJ_SCALED; |
| 196 | } else { |
Roman Zippel | 8f807f8 | 2006-09-30 23:28:25 -0700 | [diff] [blame] | 197 | tick_length += (s64)(time_adjust * NSEC_PER_USEC / |
john stultz | f4304ab | 2007-02-16 01:27:26 -0800 | [diff] [blame] | 198 | NTP_INTERVAL_FREQ) << TICK_LENGTH_SHIFT; |
Jim Houston | bb1d860 | 2006-10-28 10:38:56 -0700 | [diff] [blame] | 199 | time_adjust = 0; |
Roman Zippel | 8f807f8 | 2006-09-30 23:28:25 -0700 | [diff] [blame] | 200 | } |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 201 | } |
| 202 | } |
| 203 | |
| 204 | /* |
| 205 | * Return how long ticks are at the moment, that is, how much time |
| 206 | * update_wall_time_one_tick will add to xtime next time we call it |
| 207 | * (assuming no calls to do_adjtimex in the meantime). |
| 208 | * The return value is in fixed-point nanoseconds shifted by the |
| 209 | * specified number of bits to the right of the binary point. |
| 210 | * This function has no side-effects. |
| 211 | */ |
| 212 | u64 current_tick_length(void) |
| 213 | { |
Roman Zippel | 8f807f8 | 2006-09-30 23:28:25 -0700 | [diff] [blame] | 214 | return tick_length; |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 215 | } |
| 216 | |
Thomas Gleixner | 8264445 | 2007-07-21 04:37:37 -0700 | [diff] [blame] | 217 | #ifdef CONFIG_GENERIC_CMOS_UPDATE |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 218 | |
Thomas Gleixner | 8264445 | 2007-07-21 04:37:37 -0700 | [diff] [blame] | 219 | /* Disable the cmos update - used by virtualization and embedded */ |
| 220 | int no_sync_cmos_clock __read_mostly; |
| 221 | |
| 222 | static void sync_cmos_clock(unsigned long dummy); |
| 223 | |
| 224 | static DEFINE_TIMER(sync_cmos_timer, sync_cmos_clock, 0, 0); |
| 225 | |
| 226 | static void sync_cmos_clock(unsigned long dummy) |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 227 | { |
Thomas Gleixner | 8264445 | 2007-07-21 04:37:37 -0700 | [diff] [blame] | 228 | struct timespec now, next; |
| 229 | int fail = 1; |
| 230 | |
| 231 | /* |
| 232 | * If we have an externally synchronized Linux clock, then update |
| 233 | * CMOS clock accordingly every ~11 minutes. Set_rtc_mmss() has to be |
| 234 | * called as close as possible to 500 ms before the new second starts. |
| 235 | * This code is run on a timer. If the clock is set, that timer |
| 236 | * may not expire at the correct time. Thus, we adjust... |
| 237 | */ |
| 238 | if (!ntp_synced()) |
| 239 | /* |
| 240 | * Not synced, exit, do not restart a timer (if one is |
| 241 | * running, let it run out). |
| 242 | */ |
| 243 | return; |
| 244 | |
| 245 | getnstimeofday(&now); |
David P. Reed | fa6a1a5 | 2007-11-14 17:49:21 -0500 | [diff] [blame] | 246 | if (abs(now.tv_nsec - (NSEC_PER_SEC / 2)) <= tick_nsec / 2) |
Thomas Gleixner | 8264445 | 2007-07-21 04:37:37 -0700 | [diff] [blame] | 247 | fail = update_persistent_clock(now); |
| 248 | |
| 249 | next.tv_nsec = (NSEC_PER_SEC / 2) - now.tv_nsec; |
| 250 | if (next.tv_nsec <= 0) |
| 251 | next.tv_nsec += NSEC_PER_SEC; |
| 252 | |
| 253 | if (!fail) |
| 254 | next.tv_sec = 659; |
| 255 | else |
| 256 | next.tv_sec = 0; |
| 257 | |
| 258 | if (next.tv_nsec >= NSEC_PER_SEC) { |
| 259 | next.tv_sec++; |
| 260 | next.tv_nsec -= NSEC_PER_SEC; |
| 261 | } |
| 262 | mod_timer(&sync_cmos_timer, jiffies + timespec_to_jiffies(&next)); |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 263 | } |
| 264 | |
Thomas Gleixner | 8264445 | 2007-07-21 04:37:37 -0700 | [diff] [blame] | 265 | static void notify_cmos_timer(void) |
| 266 | { |
Tony Breeds | 298a5df | 2007-09-11 15:24:03 -0700 | [diff] [blame] | 267 | if (!no_sync_cmos_clock) |
Thomas Gleixner | 8264445 | 2007-07-21 04:37:37 -0700 | [diff] [blame] | 268 | mod_timer(&sync_cmos_timer, jiffies + 1); |
| 269 | } |
| 270 | |
| 271 | #else |
| 272 | static inline void notify_cmos_timer(void) { } |
| 273 | #endif |
| 274 | |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 275 | /* adjtimex mainly allows reading (and writing, if superuser) of |
| 276 | * kernel time-keeping variables. used by xntpd. |
| 277 | */ |
| 278 | int do_adjtimex(struct timex *txc) |
| 279 | { |
Roman Zippel | eea83d8 | 2008-05-01 04:34:33 -0700 | [diff] [blame^] | 280 | struct timespec ts; |
Roman Zippel | ee9851b | 2008-05-01 04:34:32 -0700 | [diff] [blame] | 281 | long save_adjust; |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 282 | int result; |
| 283 | |
| 284 | /* In order to modify anything, you gotta be super-user! */ |
| 285 | if (txc->modes && !capable(CAP_SYS_TIME)) |
| 286 | return -EPERM; |
| 287 | |
| 288 | /* Now we validate the data before disabling interrupts */ |
| 289 | |
John Stultz | 52bfb36 | 2007-11-26 20:42:19 +0100 | [diff] [blame] | 290 | if ((txc->modes & ADJ_OFFSET_SINGLESHOT) == ADJ_OFFSET_SINGLESHOT) { |
Roman Zippel | eea83d8 | 2008-05-01 04:34:33 -0700 | [diff] [blame^] | 291 | /* singleshot must not be used with any other mode bits */ |
| 292 | if (txc->modes & ~ADJ_OFFSET_SS_READ) |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 293 | return -EINVAL; |
John Stultz | 52bfb36 | 2007-11-26 20:42:19 +0100 | [diff] [blame] | 294 | } |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 295 | |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 296 | /* if the quartz is off by more than 10% something is VERY wrong ! */ |
| 297 | if (txc->modes & ADJ_TICK) |
| 298 | if (txc->tick < 900000/USER_HZ || |
| 299 | txc->tick > 1100000/USER_HZ) |
| 300 | return -EINVAL; |
| 301 | |
| 302 | write_seqlock_irq(&xtime_lock); |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 303 | |
| 304 | /* Save for later - semantics of adjtime is to return old value */ |
Roman Zippel | 8f807f8 | 2006-09-30 23:28:25 -0700 | [diff] [blame] | 305 | save_adjust = time_adjust; |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 306 | |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 307 | /* If there are input parameters, then process them */ |
Roman Zippel | ee9851b | 2008-05-01 04:34:32 -0700 | [diff] [blame] | 308 | if (txc->modes) { |
Roman Zippel | eea83d8 | 2008-05-01 04:34:33 -0700 | [diff] [blame^] | 309 | if (txc->modes & ADJ_STATUS) { |
| 310 | if ((time_status & STA_PLL) && |
| 311 | !(txc->status & STA_PLL)) { |
| 312 | time_state = TIME_OK; |
| 313 | time_status = STA_UNSYNC; |
| 314 | } |
| 315 | /* only set allowed bits */ |
| 316 | time_status &= STA_RONLY; |
| 317 | time_status |= txc->status & ~STA_RONLY; |
| 318 | } |
| 319 | |
| 320 | if (txc->modes & ADJ_NANO) |
| 321 | time_status |= STA_NANO; |
| 322 | if (txc->modes & ADJ_MICRO) |
| 323 | time_status &= ~STA_NANO; |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 324 | |
Roman Zippel | ee9851b | 2008-05-01 04:34:32 -0700 | [diff] [blame] | 325 | if (txc->modes & ADJ_FREQUENCY) { |
Roman Zippel | eea83d8 | 2008-05-01 04:34:33 -0700 | [diff] [blame^] | 326 | time_freq = min(txc->freq, MAXFREQ); |
| 327 | time_freq = min(time_freq, -MAXFREQ); |
| 328 | time_freq = ((s64)time_freq * NSEC_PER_USEC) |
Roman Zippel | ee9851b | 2008-05-01 04:34:32 -0700 | [diff] [blame] | 329 | >> (SHIFT_USEC - SHIFT_NSEC); |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 330 | } |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 331 | |
Roman Zippel | eea83d8 | 2008-05-01 04:34:33 -0700 | [diff] [blame^] | 332 | if (txc->modes & ADJ_MAXERROR) |
Roman Zippel | ee9851b | 2008-05-01 04:34:32 -0700 | [diff] [blame] | 333 | time_maxerror = txc->maxerror; |
Roman Zippel | eea83d8 | 2008-05-01 04:34:33 -0700 | [diff] [blame^] | 334 | if (txc->modes & ADJ_ESTERROR) |
Roman Zippel | ee9851b | 2008-05-01 04:34:32 -0700 | [diff] [blame] | 335 | time_esterror = txc->esterror; |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 336 | |
Roman Zippel | ee9851b | 2008-05-01 04:34:32 -0700 | [diff] [blame] | 337 | if (txc->modes & ADJ_TIMECONST) { |
Roman Zippel | eea83d8 | 2008-05-01 04:34:33 -0700 | [diff] [blame^] | 338 | time_constant = txc->constant; |
| 339 | if (!(time_status & STA_NANO)) |
| 340 | time_constant += 4; |
| 341 | time_constant = min(time_constant, (long)MAXTC); |
| 342 | time_constant = max(time_constant, 0l); |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 343 | } |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 344 | |
Roman Zippel | ee9851b | 2008-05-01 04:34:32 -0700 | [diff] [blame] | 345 | if (txc->modes & ADJ_OFFSET) { |
| 346 | if (txc->modes == ADJ_OFFSET_SINGLESHOT) |
| 347 | /* adjtime() is independent from ntp_adjtime() */ |
| 348 | time_adjust = txc->offset; |
| 349 | else |
| 350 | ntp_update_offset(txc->offset); |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 351 | } |
Roman Zippel | ee9851b | 2008-05-01 04:34:32 -0700 | [diff] [blame] | 352 | if (txc->modes & ADJ_TICK) |
| 353 | tick_usec = txc->tick; |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 354 | |
Roman Zippel | ee9851b | 2008-05-01 04:34:32 -0700 | [diff] [blame] | 355 | if (txc->modes & (ADJ_TICK|ADJ_FREQUENCY|ADJ_OFFSET)) |
| 356 | ntp_update_frequency(); |
| 357 | } |
Roman Zippel | eea83d8 | 2008-05-01 04:34:33 -0700 | [diff] [blame^] | 358 | |
| 359 | result = time_state; /* mostly `TIME_OK' */ |
Roman Zippel | ee9851b | 2008-05-01 04:34:32 -0700 | [diff] [blame] | 360 | if (time_status & (STA_UNSYNC|STA_CLOCKERR)) |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 361 | result = TIME_ERROR; |
| 362 | |
John Stultz | 52bfb36 | 2007-11-26 20:42:19 +0100 | [diff] [blame] | 363 | if ((txc->modes == ADJ_OFFSET_SINGLESHOT) || |
Roman Zippel | ee9851b | 2008-05-01 04:34:32 -0700 | [diff] [blame] | 364 | (txc->modes == ADJ_OFFSET_SS_READ)) |
john stultz | d62ac21 | 2007-03-26 21:32:26 -0800 | [diff] [blame] | 365 | txc->offset = save_adjust; |
Roman Zippel | eea83d8 | 2008-05-01 04:34:33 -0700 | [diff] [blame^] | 366 | else { |
john stultz | d62ac21 | 2007-03-26 21:32:26 -0800 | [diff] [blame] | 367 | txc->offset = ((long)shift_right(time_offset, SHIFT_UPDATE)) * |
Roman Zippel | eea83d8 | 2008-05-01 04:34:33 -0700 | [diff] [blame^] | 368 | NTP_INTERVAL_FREQ; |
| 369 | if (!(time_status & STA_NANO)) |
| 370 | txc->offset /= NSEC_PER_USEC; |
| 371 | } |
john stultz | d62ac21 | 2007-03-26 21:32:26 -0800 | [diff] [blame] | 372 | txc->freq = (time_freq / NSEC_PER_USEC) << |
| 373 | (SHIFT_USEC - SHIFT_NSEC); |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 374 | txc->maxerror = time_maxerror; |
| 375 | txc->esterror = time_esterror; |
| 376 | txc->status = time_status; |
| 377 | txc->constant = time_constant; |
Adrian Bunk | 70bc42f | 2006-09-30 23:28:29 -0700 | [diff] [blame] | 378 | txc->precision = 1; |
Roman Zippel | 97eebe1 | 2006-09-30 23:28:26 -0700 | [diff] [blame] | 379 | txc->tolerance = MAXFREQ; |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 380 | txc->tick = tick_usec; |
| 381 | |
| 382 | /* PPS is not implemented, so these are zero */ |
| 383 | txc->ppsfreq = 0; |
| 384 | txc->jitter = 0; |
| 385 | txc->shift = 0; |
| 386 | txc->stabil = 0; |
| 387 | txc->jitcnt = 0; |
| 388 | txc->calcnt = 0; |
| 389 | txc->errcnt = 0; |
| 390 | txc->stbcnt = 0; |
| 391 | write_sequnlock_irq(&xtime_lock); |
Roman Zippel | ee9851b | 2008-05-01 04:34:32 -0700 | [diff] [blame] | 392 | |
Roman Zippel | eea83d8 | 2008-05-01 04:34:33 -0700 | [diff] [blame^] | 393 | getnstimeofday(&ts); |
| 394 | txc->time.tv_sec = ts.tv_sec; |
| 395 | txc->time.tv_usec = ts.tv_nsec; |
| 396 | if (!(time_status & STA_NANO)) |
| 397 | txc->time.tv_usec /= NSEC_PER_USEC; |
Roman Zippel | ee9851b | 2008-05-01 04:34:32 -0700 | [diff] [blame] | 398 | |
Thomas Gleixner | 8264445 | 2007-07-21 04:37:37 -0700 | [diff] [blame] | 399 | notify_cmos_timer(); |
Roman Zippel | ee9851b | 2008-05-01 04:34:32 -0700 | [diff] [blame] | 400 | |
| 401 | return result; |
john stultz | 4c7ee8d | 2006-09-30 23:28:22 -0700 | [diff] [blame] | 402 | } |
Roman Zippel | 10a398d | 2008-03-04 15:14:26 -0800 | [diff] [blame] | 403 | |
| 404 | static int __init ntp_tick_adj_setup(char *str) |
| 405 | { |
| 406 | ntp_tick_adj = simple_strtol(str, NULL, 0); |
| 407 | return 1; |
| 408 | } |
| 409 | |
| 410 | __setup("ntp_tick_adj=", ntp_tick_adj_setup); |