Annotation of embedaddon/ntp/ntpd/refclock_neoclock4x.c, revision 1.1.1.1
1.1 misho 1: /*
2: *
3: * Refclock_neoclock4x.c
4: * - NeoClock4X driver for DCF77 or FIA Timecode
5: *
6: * Date: 2009-12-04 v1.16
7: *
8: * see http://www.linum.com/redir/jump/id=neoclock4x&action=redir
9: * for details about the NeoClock4X device
10: *
11: */
12:
13: #ifdef HAVE_CONFIG_H
14: # include "config.h"
15: #endif
16:
17: #if defined(REFCLOCK) && (defined(CLOCK_NEOCLOCK4X))
18:
19: #include <unistd.h>
20: #include <sys/time.h>
21: #include <sys/types.h>
22: #include <termios.h>
23: #include <sys/ioctl.h>
24: #include <ctype.h>
25:
26: #include "ntpd.h"
27: #include "ntp_io.h"
28: #include "ntp_control.h"
29: #include "ntp_refclock.h"
30: #include "ntp_unixtime.h"
31: #include "ntp_stdlib.h"
32:
33: #if defined HAVE_SYS_MODEM_H
34: # include <sys/modem.h>
35: # ifndef __QNXNTO__
36: # define TIOCMSET MCSETA
37: # define TIOCMGET MCGETA
38: # define TIOCM_RTS MRTS
39: # endif
40: #endif
41:
42: #ifdef HAVE_TERMIOS_H
43: # ifdef TERMIOS_NEEDS__SVID3
44: # define _SVID3
45: # endif
46: # include <termios.h>
47: # ifdef TERMIOS_NEEDS__SVID3
48: # undef _SVID3
49: # endif
50: #endif
51:
52: #ifdef HAVE_SYS_IOCTL_H
53: # include <sys/ioctl.h>
54: #endif
55:
56: /*
57: * NTP version 4.20 change the pp->msec field to pp->nsec.
58: * To allow to support older ntp versions with this sourcefile
59: * you can define NTP_PRE_420 to allow this driver to compile
60: * with ntp version back to 4.1.2.
61: *
62: */
63: #if 0
64: #define NTP_PRE_420
65: #endif
66:
67: /*
68: * If you want the driver for whatever reason to not use
69: * the TX line to send anything to your NeoClock4X
70: * device you must tell the NTP refclock driver which
71: * firmware you NeoClock4X device uses.
72: *
73: * If you want to enable this feature change the "#if 0"
74: * line to "#if 1" and make sure that the defined firmware
75: * matches the firmware off your NeoClock4X receiver!
76: *
77: */
78:
79: #if 0
80: #define NEOCLOCK4X_FIRMWARE NEOCLOCK4X_FIRMWARE_VERSION_A
81: #endif
82:
83: /* at this time only firmware version A is known */
84: #define NEOCLOCK4X_FIRMWARE_VERSION_A 'A'
85:
86: #define NEOCLOCK4X_TIMECODELEN 37
87:
88: #define NEOCLOCK4X_OFFSET_SERIAL 3
89: #define NEOCLOCK4X_OFFSET_RADIOSIGNAL 9
90: #define NEOCLOCK4X_OFFSET_DAY 12
91: #define NEOCLOCK4X_OFFSET_MONTH 14
92: #define NEOCLOCK4X_OFFSET_YEAR 16
93: #define NEOCLOCK4X_OFFSET_HOUR 18
94: #define NEOCLOCK4X_OFFSET_MINUTE 20
95: #define NEOCLOCK4X_OFFSET_SECOND 22
96: #define NEOCLOCK4X_OFFSET_HSEC 24
97: #define NEOCLOCK4X_OFFSET_DOW 26
98: #define NEOCLOCK4X_OFFSET_TIMESOURCE 28
99: #define NEOCLOCK4X_OFFSET_DSTSTATUS 29
100: #define NEOCLOCK4X_OFFSET_QUARZSTATUS 30
101: #define NEOCLOCK4X_OFFSET_ANTENNA1 31
102: #define NEOCLOCK4X_OFFSET_ANTENNA2 33
103: #define NEOCLOCK4X_OFFSET_CRC 35
104:
105: #define NEOCLOCK4X_DRIVER_VERSION "1.16 (2009-12-04)"
106:
107: #define NSEC_TO_MILLI 1000000
108:
109: struct neoclock4x_unit {
110: l_fp laststamp; /* last receive timestamp */
111: short unit; /* NTP refclock unit number */
112: u_long polled; /* flag to detect noreplies */
113: char leap_status; /* leap second flag */
114: int recvnow;
115:
116: char firmware[80];
117: char firmwaretag;
118: char serial[7];
119: char radiosignal[4];
120: char timesource;
121: char dststatus;
122: char quarzstatus;
123: int antenna1;
124: int antenna2;
125: int utc_year;
126: int utc_month;
127: int utc_day;
128: int utc_hour;
129: int utc_minute;
130: int utc_second;
131: int utc_msec;
132: };
133:
134: static int neoclock4x_start (int, struct peer *);
135: static void neoclock4x_shutdown (int, struct peer *);
136: static void neoclock4x_receive (struct recvbuf *);
137: static void neoclock4x_poll (int, struct peer *);
138: static void neoclock4x_control (int, struct refclockstat *, struct refclockstat *, struct peer *);
139:
140: static int neol_atoi_len (const char str[], int *, int);
141: static int neol_hexatoi_len (const char str[], int *, int);
142: static void neol_jdn_to_ymd (unsigned long, int *, int *, int *);
143: static void neol_localtime (unsigned long, int* , int*, int*, int*, int*, int*);
144: static unsigned long neol_mktime (int, int, int, int, int, int);
145: #if !defined(NEOCLOCK4X_FIRMWARE)
146: static int neol_query_firmware (int, int, char *, int);
147: static int neol_check_firmware (int, const char*, char *);
148: #endif
149:
150: struct refclock refclock_neoclock4x = {
151: neoclock4x_start, /* start up driver */
152: neoclock4x_shutdown, /* shut down driver */
153: neoclock4x_poll, /* transmit poll message */
154: neoclock4x_control,
155: noentry, /* initialize driver (not used) */
156: noentry, /* not used */
157: NOFLAGS /* not used */
158: };
159:
160: static int
161: neoclock4x_start(int unit,
162: struct peer *peer)
163: {
164: struct neoclock4x_unit *up;
165: struct refclockproc *pp;
166: int fd;
167: char dev[20];
168: int sl232;
169: #if defined(HAVE_TERMIOS)
170: struct termios termsettings;
171: #endif
172: #if !defined(NEOCLOCK4X_FIRMWARE)
173: int tries;
174: #endif
175:
176: (void) snprintf(dev, sizeof(dev)-1, "/dev/neoclock4x-%d", unit);
177:
178: /* LDISC_STD, LDISC_RAW
179: * Open serial port. Use CLK line discipline, if available.
180: */
181: fd = refclock_open(dev, B2400, LDISC_STD);
182: if(fd <= 0)
183: {
184: return (0);
185: }
186:
187: #if defined(HAVE_TERMIOS)
188:
189: #if 1
190: if(tcgetattr(fd, &termsettings) < 0)
191: {
192: msyslog(LOG_CRIT, "NeoClock4X(%d): (tcgetattr) can't query serial port settings: %m", unit);
193: (void) close(fd);
194: return (0);
195: }
196:
197: /* 2400 Baud 8N2 */
198: termsettings.c_iflag = IGNBRK | IGNPAR | ICRNL;
199: termsettings.c_oflag = 0;
200: termsettings.c_cflag = CS8 | CSTOPB | CLOCAL | CREAD;
201: (void)cfsetispeed(&termsettings, (u_int)B2400);
202: (void)cfsetospeed(&termsettings, (u_int)B2400);
203:
204: if(tcsetattr(fd, TCSANOW, &termsettings) < 0)
205: {
206: msyslog(LOG_CRIT, "NeoClock4X(%d): (tcsetattr) can't set serial port 2400 8N2: %m", unit);
207: (void) close(fd);
208: return (0);
209: }
210:
211: #else
212: if(tcgetattr(fd, &termsettings) < 0)
213: {
214: msyslog(LOG_CRIT, "NeoClock4X(%d): (tcgetattr) can't query serial port settings: %m", unit);
215: (void) close(fd);
216: return (0);
217: }
218:
219: /* 2400 Baud 8N2 */
220: termsettings.c_cflag &= ~PARENB;
221: termsettings.c_cflag |= CSTOPB;
222: termsettings.c_cflag &= ~CSIZE;
223: termsettings.c_cflag |= CS8;
224:
225: if(tcsetattr(fd, TCSANOW, &termsettings) < 0)
226: {
227: msyslog(LOG_CRIT, "NeoClock4X(%d): (tcsetattr) can't set serial port 2400 8N2: %m", unit);
228: (void) close(fd);
229: return (0);
230: }
231: #endif
232:
233: #elif defined(HAVE_SYSV_TTYS)
234: if(ioctl(fd, TCGETA, &termsettings) < 0)
235: {
236: msyslog(LOG_CRIT, "NeoClock4X(%d): (TCGETA) can't query serial port settings: %m", unit);
237: (void) close(fd);
238: return (0);
239: }
240:
241: /* 2400 Baud 8N2 */
242: termsettings.c_cflag &= ~PARENB;
243: termsettings.c_cflag |= CSTOPB;
244: termsettings.c_cflag &= ~CSIZE;
245: termsettings.c_cflag |= CS8;
246:
247: if(ioctl(fd, TCSETA, &termsettings) < 0)
248: {
249: msyslog(LOG_CRIT, "NeoClock4X(%d): (TSGETA) can't set serial port 2400 8N2: %m", unit);
250: (void) close(fd);
251: return (0);
252: }
253: #else
254: msyslog(LOG_EMERG, "NeoClock4X(%d): don't know how to set port to 2400 8N2 with this OS!", unit);
255: (void) close(fd);
256: return (0);
257: #endif
258:
259: #if defined(TIOCMSET) && (defined(TIOCM_RTS) || defined(CIOCM_RTS))
260: /* turn on RTS, and DTR for power supply */
261: /* NeoClock4x is powered from serial line */
262: if(ioctl(fd, TIOCMGET, (caddr_t)&sl232) == -1)
263: {
264: msyslog(LOG_CRIT, "NeoClock4X(%d): can't query RTS/DTR state: %m", unit);
265: (void) close(fd);
266: return (0);
267: }
268: #ifdef TIOCM_RTS
269: sl232 = sl232 | TIOCM_DTR | TIOCM_RTS; /* turn on RTS, and DTR for power supply */
270: #else
271: sl232 = sl232 | CIOCM_DTR | CIOCM_RTS; /* turn on RTS, and DTR for power supply */
272: #endif
273: if(ioctl(fd, TIOCMSET, (caddr_t)&sl232) == -1)
274: {
275: msyslog(LOG_CRIT, "NeoClock4X(%d): can't set RTS/DTR to power neoclock4x: %m", unit);
276: (void) close(fd);
277: return (0);
278: }
279: #else
280: msyslog(LOG_EMERG, "NeoClock4X(%d): don't know how to set DTR/RTS to power NeoClock4X with this OS!",
281: unit);
282: (void) close(fd);
283: return (0);
284: #endif
285:
286: up = (struct neoclock4x_unit *) emalloc(sizeof(struct neoclock4x_unit));
287: if(!(up))
288: {
289: msyslog(LOG_ERR, "NeoClock4X(%d): can't allocate memory for: %m",unit);
290: (void) close(fd);
291: return (0);
292: }
293:
294: memset((char *)up, 0, sizeof(struct neoclock4x_unit));
295: pp = peer->procptr;
296: pp->clockdesc = "NeoClock4X";
297: pp->unitptr = (caddr_t)up;
298: pp->io.clock_recv = neoclock4x_receive;
299: pp->io.srcclock = (caddr_t)peer;
300: pp->io.datalen = 0;
301: pp->io.fd = fd;
302: /*
303: * no fudge time is given by user!
304: * use 169.583333 ms to compensate the serial line delay
305: * formula is:
306: * 2400 Baud / 11 bit = 218.18 charaters per second
307: * (NeoClock4X timecode len)
308: */
309: pp->fudgetime1 = (NEOCLOCK4X_TIMECODELEN * 11) / 2400.0;
310:
311: /*
312: * Initialize miscellaneous variables
313: */
314: peer->precision = -10;
315: peer->burst = NSTAGE;
316: memcpy((char *)&pp->refid, "neol", 4);
317:
318: up->leap_status = 0;
319: up->unit = unit;
320: strcpy(up->firmware, "?");
321: up->firmwaretag = '?';
322: strcpy(up->serial, "?");
323: strcpy(up->radiosignal, "?");
324: up->timesource = '?';
325: up->dststatus = '?';
326: up->quarzstatus = '?';
327: up->antenna1 = -1;
328: up->antenna2 = -1;
329: up->utc_year = 0;
330: up->utc_month = 0;
331: up->utc_day = 0;
332: up->utc_hour = 0;
333: up->utc_minute = 0;
334: up->utc_second = 0;
335: up->utc_msec = 0;
336:
337: #if defined(NEOCLOCK4X_FIRMWARE)
338: #if NEOCLOCK4X_FIRMWARE == NEOCLOCK4X_FIRMWARE_VERSION_A
339: strcpy(up->firmware, "(c) 2002 NEOL S.A. FRANCE / L0.01 NDF:A:* (compile time)");
340: up->firmwaretag = 'A';
341: #else
342: msyslog(LOG_EMERG, "NeoClock4X(%d): unknown firmware defined at compile time for NeoClock4X",
343: unit);
344: (void) close(fd);
345: pp->io.fd = -1;
346: free(pp->unitptr);
347: pp->unitptr = NULL;
348: return (0);
349: #endif
350: #else
351: for(tries=0; tries < 5; tries++)
352: {
353: NLOG(NLOG_CLOCKINFO)
354: msyslog(LOG_INFO, "NeoClock4X(%d): checking NeoClock4X firmware version (%d/5)", unit, tries);
355: /* wait 3 seconds for receiver to power up */
356: sleep(3);
357: if(neol_query_firmware(pp->io.fd, up->unit, up->firmware, sizeof(up->firmware)))
358: {
359: break;
360: }
361: }
362:
363: /* can I handle this firmware version? */
364: if(!neol_check_firmware(up->unit, up->firmware, &up->firmwaretag))
365: {
366: (void) close(fd);
367: pp->io.fd = -1;
368: free(pp->unitptr);
369: pp->unitptr = NULL;
370: return (0);
371: }
372: #endif
373:
374: if(!io_addclock(&pp->io))
375: {
376: msyslog(LOG_ERR, "NeoClock4X(%d): error add peer to ntpd: %m", unit);
377: (void) close(fd);
378: pp->io.fd = -1;
379: free(pp->unitptr);
380: pp->unitptr = NULL;
381: return (0);
382: }
383:
384: NLOG(NLOG_CLOCKINFO)
385: msyslog(LOG_INFO, "NeoClock4X(%d): receiver setup successful done", unit);
386:
387: return (1);
388: }
389:
390: static void
391: neoclock4x_shutdown(int unit,
392: struct peer *peer)
393: {
394: struct neoclock4x_unit *up;
395: struct refclockproc *pp;
396: int sl232;
397:
398: if(NULL != peer)
399: {
400: pp = peer->procptr;
401: if(pp != NULL)
402: {
403: up = (struct neoclock4x_unit *)pp->unitptr;
404: if(up != NULL)
405: {
406: if(-1 != pp->io.fd)
407: {
408: #if defined(TIOCMSET) && (defined(TIOCM_RTS) || defined(CIOCM_RTS))
409: /* turn on RTS, and DTR for power supply */
410: /* NeoClock4x is powered from serial line */
411: if(ioctl(pp->io.fd, TIOCMGET, (caddr_t)&sl232) == -1)
412: {
413: msyslog(LOG_CRIT, "NeoClock4X(%d): can't query RTS/DTR state: %m",
414: unit);
415: }
416: #ifdef TIOCM_RTS
417: /* turn on RTS, and DTR for power supply */
418: sl232 &= ~(TIOCM_DTR | TIOCM_RTS);
419: #else
420: /* turn on RTS, and DTR for power supply */
421: sl232 &= ~(CIOCM_DTR | CIOCM_RTS);
422: #endif
423: if(ioctl(pp->io.fd, TIOCMSET, (caddr_t)&sl232) == -1)
424: {
425: msyslog(LOG_CRIT, "NeoClock4X(%d): can't set RTS/DTR to power neoclock4x: %m",
426: unit);
427: }
428: #endif
429: io_closeclock(&pp->io);
430: }
431: free(up);
432: pp->unitptr = NULL;
433: }
434: }
435: }
436:
437: msyslog(LOG_ERR, "NeoClock4X(%d): shutdown", unit);
438:
439: NLOG(NLOG_CLOCKINFO)
440: msyslog(LOG_INFO, "NeoClock4X(%d): receiver shutdown done", unit);
441: }
442:
443: static void
444: neoclock4x_receive(struct recvbuf *rbufp)
445: {
446: struct neoclock4x_unit *up;
447: struct refclockproc *pp;
448: struct peer *peer;
449: unsigned long calc_utc;
450: int day;
451: int month; /* ddd conversion */
452: int c;
453: int dsec;
454: unsigned char calc_chksum;
455: int recv_chksum;
456:
457: peer = (struct peer *)rbufp->recv_srcclock;
458: pp = peer->procptr;
459: up = (struct neoclock4x_unit *)pp->unitptr;
460:
461: /* wait till poll interval is reached */
462: if(0 == up->recvnow)
463: return;
464:
465: /* reset poll interval flag */
466: up->recvnow = 0;
467:
468: /* read last received timecode */
469: pp->lencode = refclock_gtlin(rbufp, pp->a_lastcode, BMAX, &pp->lastrec);
470: pp->leap = LEAP_NOWARNING;
471:
472: if(NEOCLOCK4X_TIMECODELEN != pp->lencode)
473: {
474: NLOG(NLOG_CLOCKEVENT)
475: msyslog(LOG_WARNING, "NeoClock4X(%d): received data has invalid length, expected %d bytes, received %d bytes: %s",
476: up->unit, NEOCLOCK4X_TIMECODELEN, pp->lencode, pp->a_lastcode);
477: refclock_report(peer, CEVNT_BADREPLY);
478: return;
479: }
480:
481: neol_hexatoi_len(&pp->a_lastcode[NEOCLOCK4X_OFFSET_CRC], &recv_chksum, 2);
482:
483: /* calculate checksum */
484: calc_chksum = 0;
485: for(c=0; c < NEOCLOCK4X_OFFSET_CRC; c++)
486: {
487: calc_chksum += pp->a_lastcode[c];
488: }
489: if(recv_chksum != calc_chksum)
490: {
491: NLOG(NLOG_CLOCKEVENT)
492: msyslog(LOG_WARNING, "NeoClock4X(%d): received data has invalid chksum: %s",
493: up->unit, pp->a_lastcode);
494: refclock_report(peer, CEVNT_BADREPLY);
495: return;
496: }
497:
498: /* Allow synchronization even is quartz clock is
499: * never initialized.
500: * WARNING: This is dangerous!
501: */
502: up->quarzstatus = pp->a_lastcode[NEOCLOCK4X_OFFSET_QUARZSTATUS];
503: if(0==(pp->sloppyclockflag & CLK_FLAG2))
504: {
505: if('I' != up->quarzstatus)
506: {
507: NLOG(NLOG_CLOCKEVENT)
508: msyslog(LOG_NOTICE, "NeoClock4X(%d): quartz clock is not initialized: %s",
509: up->unit, pp->a_lastcode);
510: pp->leap = LEAP_NOTINSYNC;
511: refclock_report(peer, CEVNT_BADDATE);
512: return;
513: }
514: }
515: if('I' != up->quarzstatus)
516: {
517: NLOG(NLOG_CLOCKEVENT)
518: msyslog(LOG_NOTICE, "NeoClock4X(%d): using uninitialized quartz clock for time synchronization: %s",
519: up->unit, pp->a_lastcode);
520: }
521:
522: /*
523: * If NeoClock4X is not synchronized to a radio clock
524: * check if we're allowed to synchronize with the quartz
525: * clock.
526: */
527: up->timesource = pp->a_lastcode[NEOCLOCK4X_OFFSET_TIMESOURCE];
528: if(0==(pp->sloppyclockflag & CLK_FLAG2))
529: {
530: if('A' != up->timesource)
531: {
532: /* not allowed to sync with quartz clock */
533: if(0==(pp->sloppyclockflag & CLK_FLAG1))
534: {
535: refclock_report(peer, CEVNT_BADTIME);
536: pp->leap = LEAP_NOTINSYNC;
537: return;
538: }
539: }
540: }
541:
542: /* this should only used when first install is done */
543: if(pp->sloppyclockflag & CLK_FLAG4)
544: {
545: msyslog(LOG_DEBUG, "NeoClock4X(%d): received data: %s",
546: up->unit, pp->a_lastcode);
547: }
548:
549: /* 123456789012345678901234567890123456789012345 */
550: /* S/N123456DCF1004021010001202ASX1213CR\r\n */
551:
552: neol_atoi_len(&pp->a_lastcode[NEOCLOCK4X_OFFSET_YEAR], &pp->year, 2);
553: neol_atoi_len(&pp->a_lastcode[NEOCLOCK4X_OFFSET_MONTH], &month, 2);
554: neol_atoi_len(&pp->a_lastcode[NEOCLOCK4X_OFFSET_DAY], &day, 2);
555: neol_atoi_len(&pp->a_lastcode[NEOCLOCK4X_OFFSET_HOUR], &pp->hour, 2);
556: neol_atoi_len(&pp->a_lastcode[NEOCLOCK4X_OFFSET_MINUTE], &pp->minute, 2);
557: neol_atoi_len(&pp->a_lastcode[NEOCLOCK4X_OFFSET_SECOND], &pp->second, 2);
558: neol_atoi_len(&pp->a_lastcode[NEOCLOCK4X_OFFSET_HSEC], &dsec, 2);
559: #if defined(NTP_PRE_420)
560: pp->msec = dsec * 10; /* convert 1/100s from neoclock to real miliseconds */
561: #else
562: pp->nsec = dsec * 10 * NSEC_TO_MILLI; /* convert 1/100s from neoclock to nanoseconds */
563: #endif
564:
565: memcpy(up->radiosignal, &pp->a_lastcode[NEOCLOCK4X_OFFSET_RADIOSIGNAL], 3);
566: up->radiosignal[3] = 0;
567: memcpy(up->serial, &pp->a_lastcode[NEOCLOCK4X_OFFSET_SERIAL], 6);
568: up->serial[6] = 0;
569: up->dststatus = pp->a_lastcode[NEOCLOCK4X_OFFSET_DSTSTATUS];
570: neol_hexatoi_len(&pp->a_lastcode[NEOCLOCK4X_OFFSET_ANTENNA1], &up->antenna1, 2);
571: neol_hexatoi_len(&pp->a_lastcode[NEOCLOCK4X_OFFSET_ANTENNA2], &up->antenna2, 2);
572:
573: /*
574: Validate received values at least enough to prevent internal
575: array-bounds problems, etc.
576: */
577: if((pp->hour < 0) || (pp->hour > 23) ||
578: (pp->minute < 0) || (pp->minute > 59) ||
579: (pp->second < 0) || (pp->second > 60) /*Allow for leap seconds.*/ ||
580: (day < 1) || (day > 31) ||
581: (month < 1) || (month > 12) ||
582: (pp->year < 0) || (pp->year > 99)) {
583: /* Data out of range. */
584: NLOG(NLOG_CLOCKEVENT)
585: msyslog(LOG_WARNING, "NeoClock4X(%d): date/time out of range: %s",
586: up->unit, pp->a_lastcode);
587: refclock_report(peer, CEVNT_BADDATE);
588: return;
589: }
590:
591: /* Year-2000 check not needed anymore. Same problem
592: * will arise at 2099 but what should we do...?
593: *
594: * wrap 2-digit date into 4-digit
595: *
596: * if(pp->year < YEAR_PIVOT)
597: * {
598: * pp->year += 100;
599: * }
600: */
601: pp->year += 2000;
602:
603: /* adjust NeoClock4X local time to UTC */
604: calc_utc = neol_mktime(pp->year, month, day, pp->hour, pp->minute, pp->second);
605: calc_utc -= 3600;
606: /* adjust NeoClock4X daylight saving time if needed */
607: if('S' == up->dststatus)
608: calc_utc -= 3600;
609: neol_localtime(calc_utc, &pp->year, &month, &day, &pp->hour, &pp->minute, &pp->second);
610:
611: /*
612: some preparations
613: */
614: pp->day = ymd2yd(pp->year, month, day);
615: pp->leap = 0;
616:
617: if(pp->sloppyclockflag & CLK_FLAG4)
618: {
619: msyslog(LOG_DEBUG, "NeoClock4X(%d): calculated UTC date/time: %04d-%02d-%02d %02d:%02d:%02d.%03ld",
620: up->unit,
621: pp->year, month, day,
622: pp->hour, pp->minute, pp->second,
623: #if defined(NTP_PRE_420)
624: pp->msec
625: #else
626: pp->nsec/NSEC_TO_MILLI
627: #endif
628: );
629: }
630:
631: up->utc_year = pp->year;
632: up->utc_month = month;
633: up->utc_day = day;
634: up->utc_hour = pp->hour;
635: up->utc_minute = pp->minute;
636: up->utc_second = pp->second;
637: #if defined(NTP_PRE_420)
638: up->utc_msec = pp->msec;
639: #else
640: up->utc_msec = pp->nsec/NSEC_TO_MILLI;
641: #endif
642:
643: if(!refclock_process(pp))
644: {
645: NLOG(NLOG_CLOCKEVENT)
646: msyslog(LOG_WARNING, "NeoClock4X(%d): refclock_process failed!", up->unit);
647: refclock_report(peer, CEVNT_FAULT);
648: return;
649: }
650: refclock_receive(peer);
651:
652: /* report good status */
653: refclock_report(peer, CEVNT_NOMINAL);
654:
655: record_clock_stats(&peer->srcadr, pp->a_lastcode);
656: }
657:
658: static void
659: neoclock4x_poll(int unit,
660: struct peer *peer)
661: {
662: struct neoclock4x_unit *up;
663: struct refclockproc *pp;
664:
665: pp = peer->procptr;
666: up = (struct neoclock4x_unit *)pp->unitptr;
667:
668: pp->polls++;
669: up->recvnow = 1;
670: }
671:
672: static void
673: neoclock4x_control(int unit,
674: struct refclockstat *in,
675: struct refclockstat *out,
676: struct peer *peer)
677: {
678: struct neoclock4x_unit *up;
679: struct refclockproc *pp;
680:
681: if(NULL == peer)
682: {
683: msyslog(LOG_ERR, "NeoClock4X(%d): control: unit invalid/inactive", unit);
684: return;
685: }
686:
687: pp = peer->procptr;
688: if(NULL == pp)
689: {
690: msyslog(LOG_ERR, "NeoClock4X(%d): control: unit invalid/inactive", unit);
691: return;
692: }
693:
694: up = (struct neoclock4x_unit *)pp->unitptr;
695: if(NULL == up)
696: {
697: msyslog(LOG_ERR, "NeoClock4X(%d): control: unit invalid/inactive", unit);
698: return;
699: }
700:
701: if(NULL != in)
702: {
703: /* check to see if a user supplied time offset is given */
704: if(in->haveflags & CLK_HAVETIME1)
705: {
706: pp->fudgetime1 = in->fudgetime1;
707: NLOG(NLOG_CLOCKINFO)
708: msyslog(LOG_NOTICE, "NeoClock4X(%d): using fudgetime1 with %0.5fs from ntp.conf.",
709: unit, pp->fudgetime1);
710: }
711:
712: /* notify */
713: if(pp->sloppyclockflag & CLK_FLAG1)
714: {
715: NLOG(NLOG_CLOCKINFO)
716: msyslog(LOG_NOTICE, "NeoClock4X(%d): quartz clock is used to synchronize time if radio clock has no reception.", unit);
717: }
718: else
719: {
720: NLOG(NLOG_CLOCKINFO)
721: msyslog(LOG_NOTICE, "NeoClock4X(%d): time is only adjusted with radio signal reception.", unit);
722: }
723: }
724:
725: if(NULL != out)
726: {
727: char *tt;
728: char tmpbuf[80];
729:
730: out->kv_list = (struct ctl_var *)0;
731: out->type = REFCLK_NEOCLOCK4X;
732:
733: snprintf(tmpbuf, sizeof(tmpbuf)-1,
734: "%04d-%02d-%02d %02d:%02d:%02d.%03d",
735: up->utc_year, up->utc_month, up->utc_day,
736: up->utc_hour, up->utc_minute, up->utc_second,
737: up->utc_msec);
738: tt = add_var(&out->kv_list, sizeof(tmpbuf)-1, RO|DEF);
739: snprintf(tt, sizeof(tmpbuf)-1, "calc_utc=\"%s\"", tmpbuf);
740:
741: tt = add_var(&out->kv_list, 40, RO|DEF);
742: snprintf(tt, 39, "radiosignal=\"%s\"", up->radiosignal);
743: tt = add_var(&out->kv_list, 40, RO|DEF);
744: snprintf(tt, 39, "antenna1=\"%d\"", up->antenna1);
745: tt = add_var(&out->kv_list, 40, RO|DEF);
746: snprintf(tt, 39, "antenna2=\"%d\"", up->antenna2);
747: tt = add_var(&out->kv_list, 40, RO|DEF);
748: if('A' == up->timesource)
749: snprintf(tt, 39, "timesource=\"radio\"");
750: else if('C' == up->timesource)
751: snprintf(tt, 39, "timesource=\"quartz\"");
752: else
753: snprintf(tt, 39, "timesource=\"unknown\"");
754: tt = add_var(&out->kv_list, 40, RO|DEF);
755: if('I' == up->quarzstatus)
756: snprintf(tt, 39, "quartzstatus=\"synchronized\"");
757: else if('X' == up->quarzstatus)
758: snprintf(tt, 39, "quartzstatus=\"not synchronized\"");
759: else
760: snprintf(tt, 39, "quartzstatus=\"unknown\"");
761: tt = add_var(&out->kv_list, 40, RO|DEF);
762: if('S' == up->dststatus)
763: snprintf(tt, 39, "dststatus=\"summer\"");
764: else if('W' == up->dststatus)
765: snprintf(tt, 39, "dststatus=\"winter\"");
766: else
767: snprintf(tt, 39, "dststatus=\"unknown\"");
768: tt = add_var(&out->kv_list, 80, RO|DEF);
769: snprintf(tt, 79, "firmware=\"%s\"", up->firmware);
770: tt = add_var(&out->kv_list, 40, RO|DEF);
771: snprintf(tt, 39, "firmwaretag=\"%c\"", up->firmwaretag);
772: tt = add_var(&out->kv_list, 80, RO|DEF);
773: snprintf(tt, 79, "driver version=\"%s\"", NEOCLOCK4X_DRIVER_VERSION);
774: tt = add_var(&out->kv_list, 80, RO|DEF);
775: snprintf(tt, 79, "serialnumber=\"%s\"", up->serial);
776: }
777: }
778:
779: static int
780: neol_hexatoi_len(const char str[],
781: int *result,
782: int maxlen)
783: {
784: int hexdigit;
785: int i;
786: int n = 0;
787:
788: for(i=0; isxdigit((int)str[i]) && i < maxlen; i++)
789: {
790: hexdigit = isdigit((int)str[i]) ? toupper(str[i]) - '0' : toupper(str[i]) - 'A' + 10;
791: n = 16 * n + hexdigit;
792: }
793: *result = n;
794: return (n);
795: }
796:
797: static int
798: neol_atoi_len(const char str[],
799: int *result,
800: int maxlen)
801: {
802: int digit;
803: int i;
804: int n = 0;
805:
806: for(i=0; isdigit((int)str[i]) && i < maxlen; i++)
807: {
808: digit = str[i] - '0';
809: n = 10 * n + digit;
810: }
811: *result = n;
812: return (n);
813: }
814:
815: /* Converts Gregorian date to seconds since 1970-01-01 00:00:00.
816: * Assumes input in normal date format, i.e. 1980-12-31 23:59:59
817: * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
818: *
819: * [For the Julian calendar (which was used in Russia before 1917,
820: * Britain & colonies before 1752, anywhere else before 1582,
821: * and is still in use by some communities) leave out the
822: * -year/100+year/400 terms, and add 10.]
823: *
824: * This algorithm was first published by Gauss (I think).
825: *
826: * WARNING: this function will overflow on 2106-02-07 06:28:16 on
827: * machines were long is 32-bit! (However, as time_t is signed, we
828: * will already get problems at other places on 2038-01-19 03:14:08)
829: */
830: static unsigned long
831: neol_mktime(int year,
832: int mon,
833: int day,
834: int hour,
835: int min,
836: int sec)
837: {
838: if (0 >= (int) (mon -= 2)) { /* 1..12 . 11,12,1..10 */
839: mon += 12; /* Puts Feb last since it has leap day */
840: year -= 1;
841: }
842: return (((
843: (unsigned long)(year/4 - year/100 + year/400 + 367*mon/12 + day) +
844: year*365 - 719499
845: )*24 + hour /* now have hours */
846: )*60 + min /* now have minutes */
847: )*60 + sec; /* finally seconds */
848: }
849:
850: static void
851: neol_localtime(unsigned long utc,
852: int* year,
853: int* month,
854: int* day,
855: int* hour,
856: int* min,
857: int* sec)
858: {
859: *sec = utc % 60;
860: utc /= 60;
861: *min = utc % 60;
862: utc /= 60;
863: *hour = utc % 24;
864: utc /= 24;
865:
866: /* JDN Date 1/1/1970 */
867: neol_jdn_to_ymd(utc + 2440588L, year, month, day);
868: }
869:
870: static void
871: neol_jdn_to_ymd(unsigned long jdn,
872: int *yy,
873: int *mm,
874: int *dd)
875: {
876: unsigned long x, z, m, d, y;
877: unsigned long daysPer400Years = 146097UL;
878: unsigned long fudgedDaysPer4000Years = 1460970UL + 31UL;
879:
880: x = jdn + 68569UL;
881: z = 4UL * x / daysPer400Years;
882: x = x - (daysPer400Years * z + 3UL) / 4UL;
883: y = 4000UL * (x + 1) / fudgedDaysPer4000Years;
884: x = x - 1461UL * y / 4UL + 31UL;
885: m = 80UL * x / 2447UL;
886: d = x - 2447UL * m / 80UL;
887: x = m / 11UL;
888: m = m + 2UL - 12UL * x;
889: y = 100UL * (z - 49UL) + y + x;
890:
891: *yy = (int)y;
892: *mm = (int)m;
893: *dd = (int)d;
894: }
895:
896: #if !defined(NEOCLOCK4X_FIRMWARE)
897: static int
898: neol_query_firmware(int fd,
899: int unit,
900: char *firmware,
901: int maxlen)
902: {
903: char tmpbuf[256];
904: int len;
905: int lastsearch;
906: unsigned char c;
907: int last_c_was_crlf;
908: int last_crlf_conv_len;
909: int init;
910: int read_errors;
911: int flag = 0;
912: int chars_read;
913:
914: /* wait a little bit */
915: sleep(1);
916: if(-1 != write(fd, "V", 1))
917: {
918: /* wait a little bit */
919: sleep(1);
920: memset(tmpbuf, 0x00, sizeof(tmpbuf));
921:
922: len = 0;
923: lastsearch = 0;
924: last_c_was_crlf = 0;
925: last_crlf_conv_len = 0;
926: init = 1;
927: read_errors = 0;
928: chars_read = 0;
929: for(;;)
930: {
931: if(read_errors > 5)
932: {
933: msyslog(LOG_ERR, "NeoClock4X(%d): can't read firmware version (timeout)", unit);
934: strcpy(tmpbuf, "unknown due to timeout");
935: break;
936: }
937: if(chars_read > 500)
938: {
939: msyslog(LOG_ERR, "NeoClock4X(%d): can't read firmware version (garbage)", unit);
940: strcpy(tmpbuf, "unknown due to garbage input");
941: break;
942: }
943: if(-1 == read(fd, &c, 1))
944: {
945: if(EAGAIN != errno)
946: {
947: msyslog(LOG_DEBUG, "NeoClock4x(%d): read: %s", unit ,strerror(errno));
948: read_errors++;
949: }
950: else
951: {
952: sleep(1);
953: }
954: continue;
955: }
956: else
957: {
958: chars_read++;
959: }
960:
961: if(init)
962: {
963: if(0xA9 != c) /* wait for (c) char in input stream */
964: continue;
965:
966: strcpy(tmpbuf, "(c)");
967: len = 3;
968: init = 0;
969: continue;
970: }
971:
972: #if 0
973: msyslog(LOG_NOTICE, "NeoClock4X(%d): firmware %c = %02Xh", unit, c, c);
974: #endif
975:
976: if(0x0A == c || 0x0D == c)
977: {
978: if(last_c_was_crlf)
979: {
980: char *ptr;
981: ptr = strstr(&tmpbuf[lastsearch], "S/N");
982: if(NULL != ptr)
983: {
984: tmpbuf[last_crlf_conv_len] = 0;
985: flag = 1;
986: break;
987: }
988: /* convert \n to / */
989: last_crlf_conv_len = len;
990: tmpbuf[len++] = ' ';
991: tmpbuf[len++] = '/';
992: tmpbuf[len++] = ' ';
993: lastsearch = len;
994: }
995: last_c_was_crlf = 1;
996: }
997: else
998: {
999: last_c_was_crlf = 0;
1000: if(0x00 != c)
1001: tmpbuf[len++] = (char) c;
1002: }
1003: tmpbuf[len] = '\0';
1004: if(len > sizeof(tmpbuf)-5)
1005: break;
1006: }
1007: }
1008: else
1009: {
1010: msyslog(LOG_ERR, "NeoClock4X(%d): can't query firmware version", unit);
1011: strcpy(tmpbuf, "unknown error");
1012: }
1013: strncpy(firmware, tmpbuf, maxlen);
1014: firmware[maxlen] = '\0';
1015:
1016: if(flag)
1017: {
1018: NLOG(NLOG_CLOCKINFO)
1019: msyslog(LOG_INFO, "NeoClock4X(%d): firmware version: %s", unit, firmware);
1020:
1021: if(strstr(firmware, "/R2"))
1022: {
1023: msyslog(LOG_INFO, "NeoClock4X(%d): Your NeoClock4X uses the new R2 firmware release. Please note the changed LED behaviour.", unit);
1024: }
1025:
1026: }
1027:
1028: return (flag);
1029: }
1030:
1031: static int
1032: neol_check_firmware(int unit,
1033: const char *firmware,
1034: char *firmwaretag)
1035: {
1036: char *ptr;
1037:
1038: *firmwaretag = '?';
1039: ptr = strstr(firmware, "NDF:");
1040: if(NULL != ptr)
1041: {
1042: if((strlen(firmware) - strlen(ptr)) >= 7)
1043: {
1044: if(':' == *(ptr+5) && '*' == *(ptr+6))
1045: *firmwaretag = *(ptr+4);
1046: }
1047: }
1048:
1049: if('A' != *firmwaretag)
1050: {
1051: msyslog(LOG_CRIT, "NeoClock4X(%d): firmware version \"%c\" not supported with this driver version!", unit, *firmwaretag);
1052: return (0);
1053: }
1054:
1055: return (1);
1056: }
1057: #endif
1058:
1059: #else
1060: int refclock_neoclock4x_bs;
1061: #endif /* REFCLOCK */
1062:
1063: /*
1064: * History:
1065: * refclock_neoclock4x.c
1066: *
1067: * 2002/04/27 cjh
1068: * Revision 1.0 first release
1069: *
1070: * 2002/07/15 cjh
1071: * preparing for bitkeeper reposity
1072: *
1073: * 2002/09/09 cjh
1074: * Revision 1.1
1075: * - don't assume sprintf returns an int anymore
1076: * - change the way the firmware version is read
1077: * - some customers would like to put a device called
1078: * data diode to the NeoClock4X device to disable
1079: * the write line. We need to now the firmware
1080: * version even in this case. We made a compile time
1081: * definition in this case. The code was previously
1082: * only available on request.
1083: *
1084: * 2003/01/08 cjh
1085: * Revision 1.11
1086: * - changing xprinf to xnprinf to avoid buffer overflows
1087: * - change some logic
1088: * - fixed memory leaks if drivers can't initialize
1089: *
1090: * 2003/01/10 cjh
1091: * Revision 1.12
1092: * - replaced ldiv
1093: * - add code to support FreeBSD
1094: *
1095: * 2003/07/07 cjh
1096: * Revision 1.13
1097: * - fix reporting of clock status
1098: * changes. previously a bad clock
1099: * status was never reset.
1100: *
1101: * 2004/04/07 cjh
1102: * Revision 1.14
1103: * - open serial port in a way
1104: * AIX and some other OS can
1105: * handle much better
1106: *
1107: * 2006/01/11 cjh
1108: * Revision 1.15
1109: * - remove some unsued #ifdefs
1110: * - fix nsec calculation, closes #499
1111: *
1112: * 2009/12/04 cjh
1113: * Revision 1.16
1114: * - change license to ntp COPYRIGHT notice. This should allow Debian
1115: * to add this refclock driver in further releases.
1116: * - detect R2 hardware
1117: *
1118: */
1119:
1120:
1121:
1122:
1123:
1124:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to refclock_neoclock4x.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