]>
Commit | Line | Data |
---|---|---|
4c7ee8de | 1 | /* |
4c7ee8de JS |
2 | * NTP state machine interfaces and logic. |
3 | * | |
4 | * This code was mainly moved from kernel/timer.c and kernel/time.c | |
5 | * Please see those files for relevant copyright info and historical | |
6 | * changelogs. | |
7 | */ | |
aa0ac365 | 8 | #include <linux/capability.h> |
7dffa3c6 | 9 | #include <linux/clocksource.h> |
eb3f938f | 10 | #include <linux/workqueue.h> |
53bbfa9e IM |
11 | #include <linux/hrtimer.h> |
12 | #include <linux/jiffies.h> | |
13 | #include <linux/math64.h> | |
14 | #include <linux/timex.h> | |
15 | #include <linux/time.h> | |
16 | #include <linux/mm.h> | |
4c7ee8de | 17 | |
b0ee7556 | 18 | /* |
53bbfa9e | 19 | * NTP timekeeping variables: |
b0ee7556 | 20 | */ |
b0ee7556 | 21 | |
53bbfa9e IM |
22 | /* USER_HZ period (usecs): */ |
23 | unsigned long tick_usec = TICK_USEC; | |
24 | ||
25 | /* ACTHZ period (nsecs): */ | |
26 | unsigned long tick_nsec; | |
7dffa3c6 | 27 | |
53bbfa9e IM |
28 | u64 tick_length; |
29 | static u64 tick_length_base; | |
30 | ||
31 | static struct hrtimer leap_timer; | |
32 | ||
bbd12676 | 33 | #define MAX_TICKADJ 500LL /* usecs */ |
53bbfa9e | 34 | #define MAX_TICKADJ_SCALED \ |
bbd12676 | 35 | (((MAX_TICKADJ * NSEC_PER_USEC) << NTP_SCALE_SHIFT) / NTP_INTERVAL_FREQ) |
4c7ee8de JS |
36 | |
37 | /* | |
38 | * phase-lock loop variables | |
39 | */ | |
53bbfa9e IM |
40 | |
41 | /* | |
42 | * clock synchronization status | |
43 | * | |
44 | * (TIME_ERROR prevents overwriting the CMOS clock) | |
45 | */ | |
46 | static int time_state = TIME_OK; | |
47 | ||
48 | /* clock status bits: */ | |
49 | int time_status = STA_UNSYNC; | |
50 | ||
51 | /* TAI offset (secs): */ | |
52 | static long time_tai; | |
53 | ||
54 | /* time adjustment (nsecs): */ | |
55 | static s64 time_offset; | |
56 | ||
57 | /* pll time constant: */ | |
58 | static long time_constant = 2; | |
59 | ||
60 | /* maximum error (usecs): */ | |
1f5b8f8a | 61 | static long time_maxerror = NTP_PHASE_LIMIT; |
53bbfa9e IM |
62 | |
63 | /* estimated error (usecs): */ | |
1f5b8f8a | 64 | static long time_esterror = NTP_PHASE_LIMIT; |
53bbfa9e IM |
65 | |
66 | /* frequency offset (scaled nsecs/secs): */ | |
67 | static s64 time_freq; | |
68 | ||
69 | /* time at last adjustment (secs): */ | |
70 | static long time_reftime; | |
71 | ||
e1292ba1 | 72 | static long time_adjust; |
53bbfa9e | 73 | |
069569e0 IM |
74 | /* constant (boot-param configurable) NTP tick adjustment (upscaled) */ |
75 | static s64 ntp_tick_adj; | |
53bbfa9e IM |
76 | |
77 | /* | |
78 | * NTP methods: | |
79 | */ | |
4c7ee8de | 80 | |
9ce616aa IM |
81 | /* |
82 | * Update (tick_length, tick_length_base, tick_nsec), based | |
83 | * on (tick_usec, ntp_tick_adj, time_freq): | |
84 | */ | |
70bc42f9 AB |
85 | static void ntp_update_frequency(void) |
86 | { | |
9ce616aa | 87 | u64 second_length; |
bc26c31d | 88 | u64 new_base; |
9ce616aa IM |
89 | |
90 | second_length = (u64)(tick_usec * NSEC_PER_USEC * USER_HZ) | |
91 | << NTP_SCALE_SHIFT; | |
92 | ||
069569e0 | 93 | second_length += ntp_tick_adj; |
9ce616aa | 94 | second_length += time_freq; |
70bc42f9 | 95 | |
9ce616aa | 96 | tick_nsec = div_u64(second_length, HZ) >> NTP_SCALE_SHIFT; |
bc26c31d | 97 | new_base = div_u64(second_length, NTP_INTERVAL_FREQ); |
fdcedf7b JS |
98 | |
99 | /* | |
100 | * Don't wait for the next second_overflow, apply | |
bc26c31d | 101 | * the change to the tick length immediately: |
fdcedf7b | 102 | */ |
bc26c31d IM |
103 | tick_length += new_base - tick_length_base; |
104 | tick_length_base = new_base; | |
70bc42f9 AB |
105 | } |
106 | ||
478b7aab | 107 | static inline s64 ntp_update_offset_fll(s64 offset64, long secs) |
f939890b IM |
108 | { |
109 | time_status &= ~STA_MODE; | |
110 | ||
111 | if (secs < MINSEC) | |
478b7aab | 112 | return 0; |
f939890b IM |
113 | |
114 | if (!(time_status & STA_FLL) && (secs <= MAXSEC)) | |
478b7aab | 115 | return 0; |
f939890b | 116 | |
f939890b IM |
117 | time_status |= STA_MODE; |
118 | ||
478b7aab | 119 | return div_s64(offset64 << (NTP_SCALE_SHIFT - SHIFT_FLL), secs); |
f939890b IM |
120 | } |
121 | ||
ee9851b2 RZ |
122 | static void ntp_update_offset(long offset) |
123 | { | |
ee9851b2 | 124 | s64 freq_adj; |
f939890b IM |
125 | s64 offset64; |
126 | long secs; | |
ee9851b2 RZ |
127 | |
128 | if (!(time_status & STA_PLL)) | |
129 | return; | |
130 | ||
eea83d89 | 131 | if (!(time_status & STA_NANO)) |
9f14f669 | 132 | offset *= NSEC_PER_USEC; |
ee9851b2 RZ |
133 | |
134 | /* | |
135 | * Scale the phase adjustment and | |
136 | * clamp to the operating range. | |
137 | */ | |
9f14f669 RZ |
138 | offset = min(offset, MAXPHASE); |
139 | offset = max(offset, -MAXPHASE); | |
ee9851b2 RZ |
140 | |
141 | /* | |
142 | * Select how the frequency is to be controlled | |
143 | * and in which mode (PLL or FLL). | |
144 | */ | |
7e1b5847 | 145 | secs = get_seconds() - time_reftime; |
10dd31a7 | 146 | if (unlikely(time_status & STA_FREQHOLD)) |
c7986acb IM |
147 | secs = 0; |
148 | ||
7e1b5847 | 149 | time_reftime = get_seconds(); |
ee9851b2 | 150 | |
f939890b | 151 | offset64 = offset; |
8af3c153 | 152 | freq_adj = ntp_update_offset_fll(offset64, secs); |
f939890b | 153 | |
8af3c153 ML |
154 | /* |
155 | * Clamp update interval to reduce PLL gain with low | |
156 | * sampling rate (e.g. intermittent network connection) | |
157 | * to avoid instability. | |
158 | */ | |
159 | if (unlikely(secs > 1 << (SHIFT_PLL + 1 + time_constant))) | |
160 | secs = 1 << (SHIFT_PLL + 1 + time_constant); | |
161 | ||
162 | freq_adj += (offset64 * secs) << | |
163 | (NTP_SCALE_SHIFT - 2 * (SHIFT_PLL + 2 + time_constant)); | |
f939890b IM |
164 | |
165 | freq_adj = min(freq_adj + time_freq, MAXFREQ_SCALED); | |
166 | ||
167 | time_freq = max(freq_adj, -MAXFREQ_SCALED); | |
168 | ||
169 | time_offset = div_s64(offset64 << NTP_SCALE_SHIFT, NTP_INTERVAL_FREQ); | |
ee9851b2 RZ |
170 | } |
171 | ||
b0ee7556 RZ |
172 | /** |
173 | * ntp_clear - Clears the NTP state variables | |
174 | * | |
175 | * Must be called while holding a write on the xtime_lock | |
176 | */ | |
177 | void ntp_clear(void) | |
178 | { | |
53bbfa9e IM |
179 | time_adjust = 0; /* stop active adjtime() */ |
180 | time_status |= STA_UNSYNC; | |
181 | time_maxerror = NTP_PHASE_LIMIT; | |
182 | time_esterror = NTP_PHASE_LIMIT; | |
b0ee7556 RZ |
183 | |
184 | ntp_update_frequency(); | |
185 | ||
53bbfa9e IM |
186 | tick_length = tick_length_base; |
187 | time_offset = 0; | |
b0ee7556 RZ |
188 | } |
189 | ||
4c7ee8de | 190 | /* |
7dffa3c6 RZ |
191 | * Leap second processing. If in leap-insert state at the end of the |
192 | * day, the system clock is set back one second; if in leap-delete | |
193 | * state, the system clock is set ahead one second. | |
4c7ee8de | 194 | */ |
7dffa3c6 | 195 | static enum hrtimer_restart ntp_leap_second(struct hrtimer *timer) |
4c7ee8de | 196 | { |
7dffa3c6 | 197 | enum hrtimer_restart res = HRTIMER_NORESTART; |
4c7ee8de | 198 | |
ca109491 | 199 | write_seqlock(&xtime_lock); |
4c7ee8de | 200 | |
4c7ee8de JS |
201 | switch (time_state) { |
202 | case TIME_OK: | |
4c7ee8de JS |
203 | break; |
204 | case TIME_INS: | |
31089c13 | 205 | timekeeping_leap_insert(-1); |
7dffa3c6 | 206 | time_state = TIME_OOP; |
53bbfa9e IM |
207 | printk(KERN_NOTICE |
208 | "Clock: inserting leap second 23:59:60 UTC\n"); | |
cc584b21 | 209 | hrtimer_add_expires_ns(&leap_timer, NSEC_PER_SEC); |
7dffa3c6 | 210 | res = HRTIMER_RESTART; |
4c7ee8de JS |
211 | break; |
212 | case TIME_DEL: | |
31089c13 | 213 | timekeeping_leap_insert(1); |
7dffa3c6 | 214 | time_tai--; |
7dffa3c6 | 215 | time_state = TIME_WAIT; |
53bbfa9e IM |
216 | printk(KERN_NOTICE |
217 | "Clock: deleting leap second 23:59:59 UTC\n"); | |
4c7ee8de JS |
218 | break; |
219 | case TIME_OOP: | |
153b5d05 | 220 | time_tai++; |
4c7ee8de | 221 | time_state = TIME_WAIT; |
7dffa3c6 | 222 | /* fall through */ |
4c7ee8de JS |
223 | case TIME_WAIT: |
224 | if (!(time_status & (STA_INS | STA_DEL))) | |
ee9851b2 | 225 | time_state = TIME_OK; |
7dffa3c6 RZ |
226 | break; |
227 | } | |
7dffa3c6 | 228 | |
ca109491 | 229 | write_sequnlock(&xtime_lock); |
7dffa3c6 RZ |
230 | |
231 | return res; | |
232 | } | |
233 | ||
234 | /* | |
235 | * this routine handles the overflow of the microsecond field | |
236 | * | |
237 | * The tricky bits of code to handle the accurate clock support | |
238 | * were provided by Dave Mills (Mills@UDEL.EDU) of NTP fame. | |
239 | * They were originally developed for SUN and DEC kernels. | |
240 | * All the kudos should go to Dave for this stuff. | |
241 | */ | |
242 | void second_overflow(void) | |
243 | { | |
39854fe8 | 244 | s64 delta; |
7dffa3c6 RZ |
245 | |
246 | /* Bump the maxerror field */ | |
247 | time_maxerror += MAXFREQ / NSEC_PER_USEC; | |
248 | if (time_maxerror > NTP_PHASE_LIMIT) { | |
249 | time_maxerror = NTP_PHASE_LIMIT; | |
250 | time_status |= STA_UNSYNC; | |
4c7ee8de JS |
251 | } |
252 | ||
253 | /* | |
f1992393 RZ |
254 | * Compute the phase adjustment for the next second. The offset is |
255 | * reduced by a fixed factor times the time constant. | |
4c7ee8de | 256 | */ |
39854fe8 IM |
257 | tick_length = tick_length_base; |
258 | ||
259 | delta = shift_right(time_offset, SHIFT_PLL + time_constant); | |
260 | time_offset -= delta; | |
261 | tick_length += delta; | |
4c7ee8de | 262 | |
3c972c24 IM |
263 | if (!time_adjust) |
264 | return; | |
265 | ||
266 | if (time_adjust > MAX_TICKADJ) { | |
267 | time_adjust -= MAX_TICKADJ; | |
268 | tick_length += MAX_TICKADJ_SCALED; | |
269 | return; | |
4c7ee8de | 270 | } |
3c972c24 IM |
271 | |
272 | if (time_adjust < -MAX_TICKADJ) { | |
273 | time_adjust += MAX_TICKADJ; | |
274 | tick_length -= MAX_TICKADJ_SCALED; | |
275 | return; | |
276 | } | |
277 | ||
278 | tick_length += (s64)(time_adjust * NSEC_PER_USEC / NTP_INTERVAL_FREQ) | |
279 | << NTP_SCALE_SHIFT; | |
280 | time_adjust = 0; | |
4c7ee8de JS |
281 | } |
282 | ||
82644459 | 283 | #ifdef CONFIG_GENERIC_CMOS_UPDATE |
4c7ee8de | 284 | |
82644459 TG |
285 | /* Disable the cmos update - used by virtualization and embedded */ |
286 | int no_sync_cmos_clock __read_mostly; | |
287 | ||
eb3f938f | 288 | static void sync_cmos_clock(struct work_struct *work); |
82644459 | 289 | |
eb3f938f | 290 | static DECLARE_DELAYED_WORK(sync_cmos_work, sync_cmos_clock); |
82644459 | 291 | |
eb3f938f | 292 | static void sync_cmos_clock(struct work_struct *work) |
82644459 TG |
293 | { |
294 | struct timespec now, next; | |
295 | int fail = 1; | |
296 | ||
297 | /* | |
298 | * If we have an externally synchronized Linux clock, then update | |
299 | * CMOS clock accordingly every ~11 minutes. Set_rtc_mmss() has to be | |
300 | * called as close as possible to 500 ms before the new second starts. | |
301 | * This code is run on a timer. If the clock is set, that timer | |
302 | * may not expire at the correct time. Thus, we adjust... | |
303 | */ | |
53bbfa9e | 304 | if (!ntp_synced()) { |
82644459 TG |
305 | /* |
306 | * Not synced, exit, do not restart a timer (if one is | |
307 | * running, let it run out). | |
308 | */ | |
309 | return; | |
53bbfa9e | 310 | } |
82644459 TG |
311 | |
312 | getnstimeofday(&now); | |
fa6a1a55 | 313 | if (abs(now.tv_nsec - (NSEC_PER_SEC / 2)) <= tick_nsec / 2) |
82644459 TG |
314 | fail = update_persistent_clock(now); |
315 | ||
4ff4b9e1 | 316 | next.tv_nsec = (NSEC_PER_SEC / 2) - now.tv_nsec - (TICK_NSEC / 2); |
82644459 TG |
317 | if (next.tv_nsec <= 0) |
318 | next.tv_nsec += NSEC_PER_SEC; | |
319 | ||
320 | if (!fail) | |
321 | next.tv_sec = 659; | |
322 | else | |
323 | next.tv_sec = 0; | |
324 | ||
325 | if (next.tv_nsec >= NSEC_PER_SEC) { | |
326 | next.tv_sec++; | |
327 | next.tv_nsec -= NSEC_PER_SEC; | |
328 | } | |
eb3f938f | 329 | schedule_delayed_work(&sync_cmos_work, timespec_to_jiffies(&next)); |
82644459 TG |
330 | } |
331 | ||
332 | static void notify_cmos_timer(void) | |
4c7ee8de | 333 | { |
298a5df4 | 334 | if (!no_sync_cmos_clock) |
eb3f938f | 335 | schedule_delayed_work(&sync_cmos_work, 0); |
4c7ee8de JS |
336 | } |
337 | ||
82644459 TG |
338 | #else |
339 | static inline void notify_cmos_timer(void) { } | |
340 | #endif | |
341 | ||
e9629165 IM |
342 | /* |
343 | * Start the leap seconds timer: | |
344 | */ | |
345 | static inline void ntp_start_leap_timer(struct timespec *ts) | |
346 | { | |
347 | long now = ts->tv_sec; | |
348 | ||
349 | if (time_status & STA_INS) { | |
350 | time_state = TIME_INS; | |
351 | now += 86400 - now % 86400; | |
352 | hrtimer_start(&leap_timer, ktime_set(now, 0), HRTIMER_MODE_ABS); | |
353 | ||
354 | return; | |
355 | } | |
356 | ||
357 | if (time_status & STA_DEL) { | |
358 | time_state = TIME_DEL; | |
359 | now += 86400 - (now + 1) % 86400; | |
360 | hrtimer_start(&leap_timer, ktime_set(now, 0), HRTIMER_MODE_ABS); | |
361 | } | |
362 | } | |
80f22571 IM |
363 | |
364 | /* | |
365 | * Propagate a new txc->status value into the NTP state: | |
366 | */ | |
367 | static inline void process_adj_status(struct timex *txc, struct timespec *ts) | |
368 | { | |
80f22571 IM |
369 | if ((time_status & STA_PLL) && !(txc->status & STA_PLL)) { |
370 | time_state = TIME_OK; | |
371 | time_status = STA_UNSYNC; | |
372 | } | |
80f22571 IM |
373 | |
374 | /* | |
375 | * If we turn on PLL adjustments then reset the | |
376 | * reference time to current time. | |
377 | */ | |
378 | if (!(time_status & STA_PLL) && (txc->status & STA_PLL)) | |
7e1b5847 | 379 | time_reftime = get_seconds(); |
80f22571 | 380 | |
a2a5ac86 JS |
381 | /* only set allowed bits */ |
382 | time_status &= STA_RONLY; | |
80f22571 IM |
383 | time_status |= txc->status & ~STA_RONLY; |
384 | ||
385 | switch (time_state) { | |
386 | case TIME_OK: | |
e9629165 | 387 | ntp_start_leap_timer(ts); |
80f22571 IM |
388 | break; |
389 | case TIME_INS: | |
390 | case TIME_DEL: | |
391 | time_state = TIME_OK; | |
e9629165 | 392 | ntp_start_leap_timer(ts); |
80f22571 IM |
393 | case TIME_WAIT: |
394 | if (!(time_status & (STA_INS | STA_DEL))) | |
395 | time_state = TIME_OK; | |
396 | break; | |
397 | case TIME_OOP: | |
398 | hrtimer_restart(&leap_timer); | |
399 | break; | |
400 | } | |
401 | } | |
402 | /* | |
403 | * Called with the xtime lock held, so we can access and modify | |
404 | * all the global NTP state: | |
405 | */ | |
406 | static inline void process_adjtimex_modes(struct timex *txc, struct timespec *ts) | |
407 | { | |
408 | if (txc->modes & ADJ_STATUS) | |
409 | process_adj_status(txc, ts); | |
410 | ||
411 | if (txc->modes & ADJ_NANO) | |
412 | time_status |= STA_NANO; | |
e9629165 | 413 | |
80f22571 IM |
414 | if (txc->modes & ADJ_MICRO) |
415 | time_status &= ~STA_NANO; | |
416 | ||
417 | if (txc->modes & ADJ_FREQUENCY) { | |
2b9d1496 | 418 | time_freq = txc->freq * PPM_SCALE; |
80f22571 IM |
419 | time_freq = min(time_freq, MAXFREQ_SCALED); |
420 | time_freq = max(time_freq, -MAXFREQ_SCALED); | |
421 | } | |
422 | ||
423 | if (txc->modes & ADJ_MAXERROR) | |
424 | time_maxerror = txc->maxerror; | |
e9629165 | 425 | |
80f22571 IM |
426 | if (txc->modes & ADJ_ESTERROR) |
427 | time_esterror = txc->esterror; | |
428 | ||
429 | if (txc->modes & ADJ_TIMECONST) { | |
430 | time_constant = txc->constant; | |
431 | if (!(time_status & STA_NANO)) | |
432 | time_constant += 4; | |
433 | time_constant = min(time_constant, (long)MAXTC); | |
434 | time_constant = max(time_constant, 0l); | |
435 | } | |
436 | ||
437 | if (txc->modes & ADJ_TAI && txc->constant > 0) | |
438 | time_tai = txc->constant; | |
439 | ||
440 | if (txc->modes & ADJ_OFFSET) | |
441 | ntp_update_offset(txc->offset); | |
e9629165 | 442 | |
80f22571 IM |
443 | if (txc->modes & ADJ_TICK) |
444 | tick_usec = txc->tick; | |
445 | ||
446 | if (txc->modes & (ADJ_TICK|ADJ_FREQUENCY|ADJ_OFFSET)) | |
447 | ntp_update_frequency(); | |
448 | } | |
449 | ||
53bbfa9e IM |
450 | /* |
451 | * adjtimex mainly allows reading (and writing, if superuser) of | |
4c7ee8de JS |
452 | * kernel time-keeping variables. used by xntpd. |
453 | */ | |
454 | int do_adjtimex(struct timex *txc) | |
455 | { | |
eea83d89 | 456 | struct timespec ts; |
4c7ee8de JS |
457 | int result; |
458 | ||
916c7a85 RZ |
459 | /* Validate the data before disabling interrupts */ |
460 | if (txc->modes & ADJ_ADJTIME) { | |
eea83d89 | 461 | /* singleshot must not be used with any other mode bits */ |
916c7a85 | 462 | if (!(txc->modes & ADJ_OFFSET_SINGLESHOT)) |
4c7ee8de | 463 | return -EINVAL; |
916c7a85 RZ |
464 | if (!(txc->modes & ADJ_OFFSET_READONLY) && |
465 | !capable(CAP_SYS_TIME)) | |
466 | return -EPERM; | |
467 | } else { | |
468 | /* In order to modify anything, you gotta be super-user! */ | |
469 | if (txc->modes && !capable(CAP_SYS_TIME)) | |
470 | return -EPERM; | |
471 | ||
53bbfa9e IM |
472 | /* |
473 | * if the quartz is off by more than 10% then | |
474 | * something is VERY wrong! | |
475 | */ | |
916c7a85 RZ |
476 | if (txc->modes & ADJ_TICK && |
477 | (txc->tick < 900000/USER_HZ || | |
478 | txc->tick > 1100000/USER_HZ)) | |
e9629165 | 479 | return -EINVAL; |
916c7a85 RZ |
480 | |
481 | if (txc->modes & ADJ_STATUS && time_state != TIME_OK) | |
482 | hrtimer_cancel(&leap_timer); | |
52bfb360 | 483 | } |
4c7ee8de | 484 | |
7dffa3c6 RZ |
485 | getnstimeofday(&ts); |
486 | ||
4c7ee8de | 487 | write_seqlock_irq(&xtime_lock); |
4c7ee8de | 488 | |
916c7a85 RZ |
489 | if (txc->modes & ADJ_ADJTIME) { |
490 | long save_adjust = time_adjust; | |
491 | ||
492 | if (!(txc->modes & ADJ_OFFSET_READONLY)) { | |
493 | /* adjtime() is independent from ntp_adjtime() */ | |
494 | time_adjust = txc->offset; | |
495 | ntp_update_frequency(); | |
496 | } | |
497 | txc->offset = save_adjust; | |
e9629165 | 498 | } else { |
ee9851b2 | 499 | |
e9629165 IM |
500 | /* If there are input parameters, then process them: */ |
501 | if (txc->modes) | |
502 | process_adjtimex_modes(txc, &ts); | |
eea83d89 | 503 | |
e9629165 | 504 | txc->offset = shift_right(time_offset * NTP_INTERVAL_FREQ, |
916c7a85 | 505 | NTP_SCALE_SHIFT); |
e9629165 IM |
506 | if (!(time_status & STA_NANO)) |
507 | txc->offset /= NSEC_PER_USEC; | |
508 | } | |
916c7a85 | 509 | |
eea83d89 | 510 | result = time_state; /* mostly `TIME_OK' */ |
ee9851b2 | 511 | if (time_status & (STA_UNSYNC|STA_CLOCKERR)) |
4c7ee8de JS |
512 | result = TIME_ERROR; |
513 | ||
d40e944c | 514 | txc->freq = shift_right((time_freq >> PPM_SCALE_INV_SHIFT) * |
2b9d1496 | 515 | PPM_SCALE_INV, NTP_SCALE_SHIFT); |
4c7ee8de JS |
516 | txc->maxerror = time_maxerror; |
517 | txc->esterror = time_esterror; | |
518 | txc->status = time_status; | |
519 | txc->constant = time_constant; | |
70bc42f9 | 520 | txc->precision = 1; |
074b3b87 | 521 | txc->tolerance = MAXFREQ_SCALED / PPM_SCALE; |
4c7ee8de | 522 | txc->tick = tick_usec; |
153b5d05 | 523 | txc->tai = time_tai; |
4c7ee8de JS |
524 | |
525 | /* PPS is not implemented, so these are zero */ | |
526 | txc->ppsfreq = 0; | |
527 | txc->jitter = 0; | |
528 | txc->shift = 0; | |
529 | txc->stabil = 0; | |
530 | txc->jitcnt = 0; | |
531 | txc->calcnt = 0; | |
532 | txc->errcnt = 0; | |
533 | txc->stbcnt = 0; | |
e9629165 | 534 | |
4c7ee8de | 535 | write_sequnlock_irq(&xtime_lock); |
ee9851b2 | 536 | |
eea83d89 RZ |
537 | txc->time.tv_sec = ts.tv_sec; |
538 | txc->time.tv_usec = ts.tv_nsec; | |
539 | if (!(time_status & STA_NANO)) | |
540 | txc->time.tv_usec /= NSEC_PER_USEC; | |
ee9851b2 | 541 | |
82644459 | 542 | notify_cmos_timer(); |
ee9851b2 RZ |
543 | |
544 | return result; | |
4c7ee8de | 545 | } |
10a398d0 RZ |
546 | |
547 | static int __init ntp_tick_adj_setup(char *str) | |
548 | { | |
549 | ntp_tick_adj = simple_strtol(str, NULL, 0); | |
069569e0 IM |
550 | ntp_tick_adj <<= NTP_SCALE_SHIFT; |
551 | ||
10a398d0 RZ |
552 | return 1; |
553 | } | |
554 | ||
555 | __setup("ntp_tick_adj=", ntp_tick_adj_setup); | |
7dffa3c6 RZ |
556 | |
557 | void __init ntp_init(void) | |
558 | { | |
559 | ntp_clear(); | |
560 | hrtimer_init(&leap_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS); | |
561 | leap_timer.function = ntp_leap_second; | |
562 | } |