contrib/ntp/ntpd/refclock_neoclock4x.c

   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, const 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 *, size_t);
 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 = up;
 298   pp->io.clock_recv = neoclock4x_receive;
 299   pp->io.srcclock = 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   memcpy((char *)&pp->refid, "neol", 4);
 316
 317   up->leap_status = 0;
 318   up->unit = unit;
 319   strlcpy(up->firmware, "?", sizeof(up->firmware));
 320   up->firmwaretag = '?';
 321   strlcpy(up->serial, "?", sizeof(up->serial));
 322   strlcpy(up->radiosignal, "?", sizeof(up->radiosignal));
 323   up->timesource  = '?';
 324   up->dststatus   = '?';
 325   up->quarzstatus = '?';
 326   up->antenna1    = -1;
 327   up->antenna2    = -1;
 328   up->utc_year    = 0;
 329   up->utc_month   = 0;
 330   up->utc_day     = 0;
 331   up->utc_hour    = 0;
 332   up->utc_minute  = 0;
 333   up->utc_second  = 0;
 334   up->utc_msec    = 0;
 335
 336 #if defined(NEOCLOCK4X_FIRMWARE)
 337 #if NEOCLOCK4X_FIRMWARE == NEOCLOCK4X_FIRMWARE_VERSION_A
 338   strlcpy(up->firmware, "(c) 2002 NEOL S.A. FRANCE / L0.01 NDF:A:* (compile time)",
 339           sizeof(up->firmware));
 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 = 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 = rbufp->recv_peer;
 458   pp = peer->procptr;
 459   up = 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 = pp->unitptr;
 667
 668   pp->polls++;
 669   up->recvnow = 1;
 670 }
 671
 672 static void
 673 neoclock4x_control(int unit,
 674                    const 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 = 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((unsigned char)str[i]) && i < maxlen; i++)
 789     {
 790       hexdigit = isdigit((unsigned char)str[i]) ? toupper((unsigned char)str[i]) - '0' : toupper((unsigned char)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((unsigned char)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                     size_t maxlen)
 902 {
 903   char tmpbuf[256];
 904   size_t 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               strlcpy(tmpbuf, "unknown due to timeout", sizeof(tmpbuf));
 935               break;
 936             }
 937           if(chars_read > 500)
 938             {
 939               msyslog(LOG_ERR, "NeoClock4X(%d): can't read firmware version (garbage)", unit);
 940               strlcpy(tmpbuf, "unknown due to garbage input", sizeof(tmpbuf));
 941               break;
 942             }
 943           if(-1 == read(fd, &c, 1))
 944             {
 945               if(EAGAIN != errno)
 946                 {
 947                   msyslog(LOG_DEBUG, "NeoClock4x(%d): read: %m", unit);
 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               strlcpy(tmpbuf, "(c)", sizeof(tmpbuf));
 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       strlcpy(tmpbuf, "unknown error", sizeof(tmpbuf));
1012     }
1013   if (strlcpy(firmware, tmpbuf, maxlen) >= maxlen)
1014     strlcpy(firmware, "buffer too small", maxlen);
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