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