contrib/ntp/ntpd/refclock_leitch.c

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