![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to refclock_leitch.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / ntpd|
Return to refclock_leitch.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / ntpd |
1.1 misho 1: /*
2: * refclock_leitch - clock driver for the Leitch CSD-5300 Master Clock
3: */
4:
5: #ifdef HAVE_CONFIG_H
6: # include <config.h>
7: #endif
8:
9: #if defined(REFCLOCK) && defined(CLOCK_LEITCH)
10:
11: #include "ntpd.h"
12: #include "ntp_io.h"
13: #include "ntp_refclock.h"
14: #include "ntp_unixtime.h"
15:
16: #include <stdio.h>
17: #include <ctype.h>
18:
19: #ifdef STREAM
20: #include <stropts.h>
21: #if defined(LEITCHCLK)
22: #include <sys/clkdefs.h>
23: #endif /* LEITCHCLK */
24: #endif /* STREAM */
25:
26: #include "ntp_stdlib.h"
27:
28:
29: /*
30: * Driver for Leitch CSD-5300 Master Clock System
31: *
32: * COMMANDS:
33: * DATE: D <CR>
34: * TIME: T <CR>
35: * STATUS: S <CR>
36: * LOOP: L <CR>
37: *
38: * FORMAT:
39: * DATE: YYMMDD<CR>
40: * TIME: <CR>/HHMMSS <CR>/HHMMSS <CR>/HHMMSS <CR>/
41: * second bondaried on the stop bit of the <CR>
42: * second boundaries at '/' above.
43: * STATUS: G (good), D (diag fail), T (time not provided) or
44: * P (last phone update failed)
45: */
46: #define PRECISION (-20) /* 1x10-8 */
47: #define MAXUNITS 1 /* max number of LEITCH units */
48: #define LEITCHREFID "ATOM" /* reference id */
49: #define LEITCH_DESCRIPTION "Leitch: CSD 5300 Master Clock System Driver"
50: #define LEITCH232 "/dev/leitch%d" /* name of radio device */
51: #define SPEED232 B300 /* uart speed (300 baud) */
52: #ifdef DEBUG
53: #define leitch_send(A,M) \
54: if (debug) fprintf(stderr,"write leitch %s\n",M); \
55: if ((write(A->leitchio.fd,M,sizeof(M)) < 0)) {\
56: if (debug) \
57: fprintf(stderr, "leitch_send: unit %d send failed\n", A->unit); \
58: else \
59: msyslog(LOG_ERR, "leitch_send: unit %d send failed %m",A->unit);}
60: #else
61: #define leitch_send(A,M) \
62: if ((write(A->leitchio.fd,M,sizeof(M)) < 0)) {\
63: msyslog(LOG_ERR, "leitch_send: unit %d send failed %m",A->unit);}
64: #endif
65:
66: #define STATE_IDLE 0
67: #define STATE_DATE 1
68: #define STATE_TIME1 2
69: #define STATE_TIME2 3
70: #define STATE_TIME3 4
71:
72: /*
73: * LEITCH unit control structure
74: */
75: struct leitchunit {
76: struct peer *peer;
77: struct refclockio leitchio;
78: u_char unit;
79: short year;
80: short yearday;
81: short month;
82: short day;
83: short hour;
84: short second;
85: short minute;
86: short state;
87: u_short fudge1;
88: l_fp reftime1;
89: l_fp reftime2;
90: l_fp reftime3;
91: l_fp codetime1;
92: l_fp codetime2;
93: l_fp codetime3;
94: u_long yearstart;
95: };
96:
97: /*
98: * Function prototypes
99: */
100: static void leitch_init (void);
101: static int leitch_start (int, struct peer *);
102: static void leitch_shutdown (int, struct peer *);
103: static void leitch_poll (int, struct peer *);
104: static void leitch_control (int, struct refclockstat *, struct refclockstat *, struct peer *);
105: #define leitch_buginfo noentry
106: static void leitch_receive (struct recvbuf *);
107: static void leitch_process (struct leitchunit *);
108: #if 0
109: static void leitch_timeout (struct peer *);
110: #endif
111: static int leitch_get_date (struct recvbuf *, struct leitchunit *);
112: static int leitch_get_time (struct recvbuf *, struct leitchunit *, int);
113: static int days_per_year (int);
114:
115: static struct leitchunit leitchunits[MAXUNITS];
116: static u_char unitinuse[MAXUNITS];
117: static u_char stratumtouse[MAXUNITS];
118: static u_int32 refid[MAXUNITS];
119:
120: static char days_in_month [] = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
121:
122: /*
123: * Transfer vector
124: */
125: struct refclock refclock_leitch = {
126: leitch_start, leitch_shutdown, leitch_poll,
127: leitch_control, leitch_init, leitch_buginfo, NOFLAGS
128: };
129:
130: /*
131: * leitch_init - initialize internal leitch driver data
132: */
133: static void
134: leitch_init(void)
135: {
136: int i;
137:
138: memset((char*)leitchunits, 0, sizeof(leitchunits));
139: memset((char*)unitinuse, 0, sizeof(unitinuse));
140: for (i = 0; i < MAXUNITS; i++)
141: memcpy((char *)&refid[i], LEITCHREFID, 4);
142: }
143:
144: /*
145: * leitch_shutdown - shut down a LEITCH clock
146: */
147: static void
148: leitch_shutdown(
149: int unit,
150: struct peer *peer
151: )
152: {
153: struct leitchunit *leitch;
154:
155: if (unit >= MAXUNITS) {
156: return;
157: }
158: leitch = &leitchunits[unit];
159: if (-1 != leitch->leitchio.fd)
160: io_closeclock(&leitch->leitchio);
161: #ifdef DEBUG
162: if (debug)
163: fprintf(stderr, "leitch_shutdown()\n");
164: #endif
165: }
166:
167: /*
168: * leitch_poll - called by the transmit procedure
169: */
170: static void
171: leitch_poll(
172: int unit,
173: struct peer *peer
174: )
175: {
176: struct leitchunit *leitch;
177:
178: /* start the state machine rolling */
179:
180: #ifdef DEBUG
181: if (debug)
182: fprintf(stderr, "leitch_poll()\n");
183: #endif
184: if (unit >= MAXUNITS) {
185: /* XXXX syslog it */
186: return;
187: }
188:
189: leitch = &leitchunits[unit];
190:
191: if (leitch->state != STATE_IDLE) {
192: /* reset and wait for next poll */
193: /* XXXX syslog it */
194: leitch->state = STATE_IDLE;
195: } else {
196: leitch_send(leitch,"D\r");
197: leitch->state = STATE_DATE;
198: }
199: }
200:
201: static void
202: leitch_control(
203: int unit,
204: struct refclockstat *in,
205: struct refclockstat *out,
206: struct peer *passed_peer
207: )
208: {
209: if (unit >= MAXUNITS) {
210: msyslog(LOG_ERR,
211: "leitch_control: unit %d invalid", unit);
212: return;
213: }
214:
215: if (in) {
216: if (in->haveflags & CLK_HAVEVAL1)
217: stratumtouse[unit] = (u_char)(in->fudgeval1);
218: if (in->haveflags & CLK_HAVEVAL2)
219: refid[unit] = in->fudgeval2;
220: if (unitinuse[unit]) {
221: struct peer *peer;
222:
223: peer = (&leitchunits[unit])->peer;
224: peer->stratum = stratumtouse[unit];
225: peer->refid = refid[unit];
226: }
227: }
228:
229: if (out) {
230: memset((char *)out, 0, sizeof (struct refclockstat));
231: out->type = REFCLK_ATOM_LEITCH;
232: out->haveflags = CLK_HAVEVAL1 | CLK_HAVEVAL2;
233: out->fudgeval1 = (int32)stratumtouse[unit];
234: out->fudgeval2 = refid[unit];
235: out->p_lastcode = "";
236: out->clockdesc = LEITCH_DESCRIPTION;
237: }
238: }
239:
240: /*
241: * leitch_start - open the LEITCH devices and initialize data for processing
242: */
243: static int
244: leitch_start(
245: int unit,
246: struct peer *peer
247: )
248: {
249: struct leitchunit *leitch;
250: int fd232;
251: char leitchdev[20];
252:
253: /*
254: * Check configuration info.
255: */
256: if (unit >= MAXUNITS) {
257: msyslog(LOG_ERR, "leitch_start: unit %d invalid", unit);
258: return (0);
259: }
260:
261: if (unitinuse[unit]) {
262: msyslog(LOG_ERR, "leitch_start: unit %d in use", unit);
263: return (0);
264: }
265:
266: /*
267: * Open serial port.
268: */
269: snprintf(leitchdev, sizeof(leitchdev), LEITCH232, unit);
270: fd232 = open(leitchdev, O_RDWR, 0777);
271: if (fd232 == -1) {
272: msyslog(LOG_ERR,
273: "leitch_start: open of %s: %m", leitchdev);
274: return (0);
275: }
276:
277: leitch = &leitchunits[unit];
278: memset(leitch, 0, sizeof(*leitch));
279:
280: #if defined(HAVE_SYSV_TTYS)
281: /*
282: * System V serial line parameters (termio interface)
283: *
284: */
285: { struct termio ttyb;
286: if (ioctl(fd232, TCGETA, &ttyb) < 0) {
287: msyslog(LOG_ERR,
288: "leitch_start: ioctl(%s, TCGETA): %m", leitchdev);
289: goto screwed;
290: }
291: ttyb.c_iflag = IGNBRK|IGNPAR|ICRNL;
292: ttyb.c_oflag = 0;
293: ttyb.c_cflag = SPEED232|CS8|CLOCAL|CREAD;
294: ttyb.c_lflag = ICANON;
295: ttyb.c_cc[VERASE] = ttyb.c_cc[VKILL] = '\0';
296: if (ioctl(fd232, TCSETA, &ttyb) < 0) {
297: msyslog(LOG_ERR,
298: "leitch_start: ioctl(%s, TCSETA): %m", leitchdev);
299: goto screwed;
300: }
301: }
302: #endif /* HAVE_SYSV_TTYS */
303: #if defined(HAVE_TERMIOS)
304: /*
305: * POSIX serial line parameters (termios interface)
306: *
307: * The LEITCHCLK option provides timestamping at the driver level.
308: * It requires the tty_clk streams module.
309: */
310: { struct termios ttyb, *ttyp;
311:
312: ttyp = &ttyb;
313: if (tcgetattr(fd232, ttyp) < 0) {
314: msyslog(LOG_ERR,
315: "leitch_start: tcgetattr(%s): %m", leitchdev);
316: goto screwed;
317: }
318: ttyp->c_iflag = IGNBRK|IGNPAR|ICRNL;
319: ttyp->c_oflag = 0;
320: ttyp->c_cflag = SPEED232|CS8|CLOCAL|CREAD;
321: ttyp->c_lflag = ICANON;
322: ttyp->c_cc[VERASE] = ttyp->c_cc[VKILL] = '\0';
323: if (tcsetattr(fd232, TCSANOW, ttyp) < 0) {
324: msyslog(LOG_ERR,
325: "leitch_start: tcsetattr(%s): %m", leitchdev);
326: goto screwed;
327: }
328: if (tcflush(fd232, TCIOFLUSH) < 0) {
329: msyslog(LOG_ERR,
330: "leitch_start: tcflush(%s): %m", leitchdev);
331: goto screwed;
332: }
333: }
334: #endif /* HAVE_TERMIOS */
335: #ifdef STREAM
336: #if defined(LEITCHCLK)
337: if (ioctl(fd232, I_PUSH, "clk") < 0)
338: msyslog(LOG_ERR,
339: "leitch_start: ioctl(%s, I_PUSH, clk): %m", leitchdev);
340: if (ioctl(fd232, CLK_SETSTR, "\n") < 0)
341: msyslog(LOG_ERR,
342: "leitch_start: ioctl(%s, CLK_SETSTR): %m", leitchdev);
343: #endif /* LEITCHCLK */
344: #endif /* STREAM */
345: #if defined(HAVE_BSD_TTYS)
346: /*
347: * 4.3bsd serial line parameters (sgttyb interface)
348: *
349: * The LEITCHCLK option provides timestamping at the driver level.
350: * It requires the tty_clk line discipline and 4.3bsd or later.
351: */
352: { struct sgttyb ttyb;
353: #if defined(LEITCHCLK)
354: int ldisc = CLKLDISC;
355: #endif /* LEITCHCLK */
356:
357: if (ioctl(fd232, TIOCGETP, &ttyb) < 0) {
358: msyslog(LOG_ERR,
359: "leitch_start: ioctl(%s, TIOCGETP): %m", leitchdev);
360: goto screwed;
361: }
362: ttyb.sg_ispeed = ttyb.sg_ospeed = SPEED232;
363: #if defined(LEITCHCLK)
364: ttyb.sg_erase = ttyb.sg_kill = '\r';
365: ttyb.sg_flags = RAW;
366: #else
367: ttyb.sg_erase = ttyb.sg_kill = '\0';
368: ttyb.sg_flags = EVENP|ODDP|CRMOD;
369: #endif /* LEITCHCLK */
370: if (ioctl(fd232, TIOCSETP, &ttyb) < 0) {
371: msyslog(LOG_ERR,
372: "leitch_start: ioctl(%s, TIOCSETP): %m", leitchdev);
373: goto screwed;
374: }
375: #if defined(LEITCHCLK)
376: if (ioctl(fd232, TIOCSETD, &ldisc) < 0) {
377: msyslog(LOG_ERR,
378: "leitch_start: ioctl(%s, TIOCSETD): %m",leitchdev);
379: goto screwed;
380: }
381: #endif /* LEITCHCLK */
382: }
383: #endif /* HAVE_BSD_TTYS */
384:
385: /*
386: * Set up the structures
387: */
388: leitch->peer = peer;
389: leitch->unit = unit;
390: leitch->state = STATE_IDLE;
391: leitch->fudge1 = 15; /* 15ms */
392:
393: leitch->leitchio.clock_recv = leitch_receive;
394: leitch->leitchio.srcclock = (caddr_t) leitch;
395: leitch->leitchio.datalen = 0;
396: leitch->leitchio.fd = fd232;
397: if (!io_addclock(&leitch->leitchio)) {
398: leitch->leitchio.fd = -1;
399: goto screwed;
400: }
401:
402: /*
403: * All done. Initialize a few random peer variables, then
404: * return success.
405: */
406: peer->precision = PRECISION;
407: peer->stratum = stratumtouse[unit];
408: peer->refid = refid[unit];
409: unitinuse[unit] = 1;
410: return(1);
411:
412: /*
413: * Something broke; abandon ship.
414: */
415: screwed:
416: close(fd232);
417: return(0);
418: }
419:
420: /*
421: * leitch_receive - receive data from the serial interface on a leitch
422: * clock
423: */
424: static void
425: leitch_receive(
426: struct recvbuf *rbufp
427: )
428: {
429: struct leitchunit *leitch = (struct leitchunit *)rbufp->recv_srcclock;
430:
431: #ifdef DEBUG
432: if (debug)
433: fprintf(stderr, "leitch_recieve(%*.*s)\n",
434: rbufp->recv_length, rbufp->recv_length,
435: rbufp->recv_buffer);
436: #endif
437: if (rbufp->recv_length != 7)
438: return; /* The date is return with a trailing newline,
439: discard it. */
440:
441: switch (leitch->state) {
442: case STATE_IDLE: /* unexpected, discard and resync */
443: return;
444: case STATE_DATE:
445: if (!leitch_get_date(rbufp,leitch)) {
446: leitch->state = STATE_IDLE;
447: break;
448: }
449: leitch_send(leitch,"T\r");
450: #ifdef DEBUG
451: if (debug)
452: fprintf(stderr, "%u\n",leitch->yearday);
453: #endif
454: leitch->state = STATE_TIME1;
455: break;
456: case STATE_TIME1:
457: if (!leitch_get_time(rbufp,leitch,1)) {
458: }
459: if (!clocktime(leitch->yearday,leitch->hour,leitch->minute,
460: leitch->second, 1, rbufp->recv_time.l_ui,
461: &leitch->yearstart, &leitch->reftime1.l_ui)) {
462: leitch->state = STATE_IDLE;
463: break;
464: }
465: leitch->reftime1.l_uf = 0;
466: #ifdef DEBUG
467: if (debug)
468: fprintf(stderr, "%lu\n", (u_long)leitch->reftime1.l_ui);
469: #endif
470: MSUTOTSF(leitch->fudge1, leitch->reftime1.l_uf);
471: leitch->codetime1 = rbufp->recv_time;
472: leitch->state = STATE_TIME2;
473: break;
474: case STATE_TIME2:
475: if (!leitch_get_time(rbufp,leitch,2)) {
476: }
477: if (!clocktime(leitch->yearday,leitch->hour,leitch->minute,
478: leitch->second, 1, rbufp->recv_time.l_ui,
479: &leitch->yearstart, &leitch->reftime2.l_ui)) {
480: leitch->state = STATE_IDLE;
481: break;
482: }
483: #ifdef DEBUG
484: if (debug)
485: fprintf(stderr, "%lu\n", (u_long)leitch->reftime2.l_ui);
486: #endif
487: MSUTOTSF(leitch->fudge1, leitch->reftime2.l_uf);
488: leitch->codetime2 = rbufp->recv_time;
489: leitch->state = STATE_TIME3;
490: break;
491: case STATE_TIME3:
492: if (!leitch_get_time(rbufp,leitch,3)) {
493: }
494: if (!clocktime(leitch->yearday,leitch->hour,leitch->minute,
495: leitch->second, GMT, rbufp->recv_time.l_ui,
496: &leitch->yearstart, &leitch->reftime3.l_ui)) {
497: leitch->state = STATE_IDLE;
498: break;
499: }
500: #ifdef DEBUG
501: if (debug)
502: fprintf(stderr, "%lu\n", (u_long)leitch->reftime3.l_ui);
503: #endif
504: MSUTOTSF(leitch->fudge1, leitch->reftime3.l_uf);
505: leitch->codetime3 = rbufp->recv_time;
506: leitch_process(leitch);
507: leitch->state = STATE_IDLE;
508: break;
509: default:
510: msyslog(LOG_ERR,
511: "leitech_receive: invalid state %d unit %d",
512: leitch->state, leitch->unit);
513: }
514: }
515:
516: /*
517: * leitch_process - process a pile of samples from the clock
518: *
519: * This routine uses a three-stage median filter to calculate offset and
520: * dispersion. reduce jitter. The dispersion is calculated as the span
521: * of the filter (max - min), unless the quality character (format 2) is
522: * non-blank, in which case the dispersion is calculated on the basis of
523: * the inherent tolerance of the internal radio oscillator, which is
524: * +-2e-5 according to the radio specifications.
525: */
526: static void
527: leitch_process(
528: struct leitchunit *leitch
529: )
530: {
531: l_fp off;
532: l_fp tmp_fp;
533: /*double doffset;*/
534:
535: off = leitch->reftime1;
536: L_SUB(&off,&leitch->codetime1);
537: tmp_fp = leitch->reftime2;
538: L_SUB(&tmp_fp,&leitch->codetime2);
539: if (L_ISGEQ(&off,&tmp_fp))
540: off = tmp_fp;
541: tmp_fp = leitch->reftime3;
542: L_SUB(&tmp_fp,&leitch->codetime3);
543:
544: if (L_ISGEQ(&off,&tmp_fp))
545: off = tmp_fp;
546: /*LFPTOD(&off, doffset);*/
547: refclock_receive(leitch->peer);
548: }
549:
550: /*
551: * days_per_year
552: */
553: static int
554: days_per_year(
555: int year
556: )
557: {
558: if (year%4) { /* not a potential leap year */
559: return (365);
560: } else {
561: if (year % 100) { /* is a leap year */
562: return (366);
563: } else {
564: if (year % 400) {
565: return (365);
566: } else {
567: return (366);
568: }
569: }
570: }
571: }
572:
573: static int
574: leitch_get_date(
575: struct recvbuf *rbufp,
576: struct leitchunit *leitch
577: )
578: {
579: int i;
580:
581: if (rbufp->recv_length < 6)
582: return(0);
583: #undef BAD /* confict: defined as (-1) in AIX sys/param.h */
584: #define BAD(A) (rbufp->recv_buffer[A] < '0') || (rbufp->recv_buffer[A] > '9')
585: if (BAD(0)||BAD(1)||BAD(2)||BAD(3)||BAD(4)||BAD(5))
586: return(0);
587: #define ATOB(A) ((rbufp->recv_buffer[A])-'0')
588: leitch->year = ATOB(0)*10 + ATOB(1);
589: leitch->month = ATOB(2)*10 + ATOB(3);
590: leitch->day = ATOB(4)*10 + ATOB(5);
591:
592: /* sanity checks */
593: if (leitch->month > 12)
594: return(0);
595: if (leitch->day > days_in_month[leitch->month-1])
596: return(0);
597:
598: /* calculate yearday */
599: i = 0;
600: leitch->yearday = leitch->day;
601:
602: while ( i < (leitch->month-1) )
603: leitch->yearday += days_in_month[i++];
604:
605: if ((days_per_year((leitch->year>90?1900:2000)+leitch->year)==365) &&
606: leitch->month > 2)
607: leitch->yearday--;
608:
609: return(1);
610: }
611:
612: /*
613: * leitch_get_time
614: */
615: static int
616: leitch_get_time(
617: struct recvbuf *rbufp,
618: struct leitchunit *leitch,
619: int which
620: )
621: {
622: if (BAD(0)||BAD(1)||BAD(2)||BAD(3)||BAD(4)||BAD(5))
623: return(0);
624: leitch->hour = ATOB(0)*10 +ATOB(1);
625: leitch->minute = ATOB(2)*10 +ATOB(3);
626: leitch->second = ATOB(4)*10 +ATOB(5);
627:
628: if ((leitch->hour > 23) || (leitch->minute > 60) ||
629: (leitch->second > 60))
630: return(0);
631: return(1);
632: }
633:
634: #else
635: int refclock_leitch_bs;
636: #endif /* REFCLOCK */