contrib/ntp/ntpd/refclock_tpro.c

   1 /*
   2  * refclock_tpro - clock driver for the KSI/Odetics TPRO-S IRIG-B reader
   3  */
   4
   5 #ifdef HAVE_CONFIG_H
   6 #include <config.h>
   7 #endif
   8
   9 #if defined(REFCLOCK) && defined(CLOCK_TPRO)
  10
  11 #include "ntpd.h"
  12 #include "ntp_io.h"
  13 #include "ntp_refclock.h"
  14 #include "ntp_unixtime.h"
  15 #include "sys/tpro.h"
  16 #include "ntp_stdlib.h"
  17
  18 #include <stdio.h>
  19 #include <ctype.h>
  20
  21 /*
  22  * This driver supports the KSI/Odetecs TPRO-S IRIG-B reader and TPRO-
  23  * SAT GPS receiver for the Sun Microsystems SBus. It requires that the
  24  * tpro.o device driver be installed and loaded.
  25  */
  26
  27 /*
  28  * TPRO interface definitions
  29  */
  30 #define DEVICE           "/dev/tpro%d" /* device name and unit */
  31 #define PRECISION       (-20)   /* precision assumed (1 us) */
  32 #define REFID           "IRIG"  /* reference ID */
  33 #define DESCRIPTION     "KSI/Odetics TPRO/S IRIG Interface" /* WRU */
  34
  35 /*
  36  * Unit control structure
  37  */
  38 struct tprounit {
  39         struct  tproval tprodata; /* data returned from tpro read */
  40 };
  41
  42 /*
  43  * Function prototypes
  44  */
  45 static  int     tpro_start      P((int, struct peer *));
  46 static  void    tpro_shutdown   P((int, struct peer *));
  47 static  void    tpro_poll       P((int unit, struct peer *));
  48
  49 /*
  50  * Transfer vector
  51  */
  52 struct  refclock refclock_tpro = {
  53         tpro_start,             /* start up driver */
  54         tpro_shutdown,          /* shut down driver */
  55         tpro_poll,              /* transmit poll message */
  56         noentry,                /* not used (old tpro_control) */
  57         noentry,                /* initialize driver (not used) */
  58         noentry,                /* not used (old tpro_buginfo) */
  59         NOFLAGS                 /* not used */
  60 };
  61
  62
  63 /*
  64  * tpro_start - open the TPRO device and initialize data for processing
  65  */
  66 static int
  67 tpro_start(
  68         int unit,
  69         struct peer *peer
  70         )
  71 {
  72         register struct tprounit *up;
  73         struct refclockproc *pp;
  74         char device[20];
  75         int fd;
  76
  77         /*
  78          * Open TPRO device
  79          */
  80         (void)sprintf(device, DEVICE, unit);
  81         fd = open(device, O_RDONLY | O_NDELAY, 0777);
  82         if (fd == -1) {
  83                 msyslog(LOG_ERR, "tpro_start: open of %s: %m", device);
  84                 return (0);
  85         }
  86
  87         /*
  88          * Allocate and initialize unit structure
  89          */
  90         if (!(up = (struct tprounit *) emalloc(sizeof(struct tprounit)))) {
  91                 (void) close(fd);
  92                 return (0);
  93         }
  94         memset((char *)up, 0, sizeof(struct tprounit));
  95         pp = peer->procptr;
  96         pp->io.clock_recv = noentry;
  97         pp->io.srcclock = (caddr_t)peer;
  98         pp->io.datalen = 0;
  99         pp->io.fd = fd;
 100         pp->unitptr = (caddr_t)up;
 101
 102         /*
 103          * Initialize miscellaneous peer variables
 104          */
 105         peer->precision = PRECISION;
 106         peer->burst = NSTAGE;
 107         pp->clockdesc = DESCRIPTION;
 108         memcpy((char *)&pp->refid, REFID, 4);
 109         return (1);
 110 }
 111
 112
 113 /*
 114  * tpro_shutdown - shut down the clock
 115  */
 116 static void
 117 tpro_shutdown(
 118         int unit,
 119         struct peer *peer
 120         )
 121 {
 122         register struct tprounit *up;
 123         struct refclockproc *pp;
 124
 125         pp = peer->procptr;
 126         up = (struct tprounit *)pp->unitptr;
 127         io_closeclock(&pp->io);
 128         free(up);
 129 }
 130
 131
 132 /*
 133  * tpro_poll - called by the transmit procedure
 134  */
 135 static void
 136 tpro_poll(
 137         int unit,
 138         struct peer *peer
 139         )
 140 {
 141         register struct tprounit *up;
 142         struct refclockproc *pp;
 143         struct tproval *tp;
 144
 145         /*
 146          * This is the main routine. It snatches the time from the TPRO
 147          * board and tacks on a local timestamp.
 148          */
 149         pp = peer->procptr;
 150         up = (struct tprounit *)pp->unitptr;
 151
 152         tp = &up->tprodata;
 153         if (read(pp->io.fd, (char *)tp, sizeof(struct tproval)) < 0) {
 154                 refclock_report(peer, CEVNT_FAULT);
 155                 return;
 156         }
 157         get_systime(&pp->lastrec);
 158         pp->polls++;
 159
 160         /*
 161          * We get down to business, check the timecode format and decode
 162          * its contents. If the timecode has invalid length or is not in
 163          * proper format, we declare bad format and exit. Note: we
 164          * can't use the sec/usec conversion produced by the driver,
 165          * since the year may be suspect. All format error checking is
 166          * done by the sprintf() and sscanf() routines.
 167          */
 168         sprintf(pp->a_lastcode,
 169             "%1x%1x%1x %1x%1x:%1x%1x:%1x%1x.%1x%1x%1x%1x%1x%1x %1x",
 170             tp->day100, tp->day10, tp->day1, tp->hour10, tp->hour1,
 171             tp->min10, tp->min1, tp->sec10, tp->sec1, tp->ms100,
 172             tp->ms10, tp->ms1, tp->usec100, tp->usec10, tp->usec1,
 173             tp->status);
 174             pp->lencode = strlen(pp->a_lastcode);
 175 #ifdef DEBUG
 176         if (debug)
 177                 printf("tpro: time %s timecode %d %s\n",
 178                    ulfptoa(&pp->lastrec, 6), pp->lencode,
 179                    pp->a_lastcode);
 180 #endif
 181         if (sscanf(pp->a_lastcode, "%3d %2d:%2d:%2d.%6ld", &pp->day,
 182             &pp->hour, &pp->minute, &pp->second, &pp->usec)
 183             != 5) {
 184                 refclock_report(peer, CEVNT_BADTIME);
 185                 return;
 186         }
 187         if (!tp->status & 0x3)
 188                 pp->leap = LEAP_NOTINSYNC;
 189         else
 190                 pp->leap = LEAP_NOWARNING;
 191         if (!refclock_process(pp)) {
 192                 refclock_report(peer, CEVNT_BADTIME);
 193                 return;
 194         }
 195         if (peer->burst > 0)
 196                 return;
 197         if (pp->coderecv == pp->codeproc) {
 198                 refclock_report(peer, CEVNT_TIMEOUT);
 199                 return;
 200         }
 201         record_clock_stats(&peer->srcadr, pp->a_lastcode);
 202         refclock_receive(peer);
 203         peer->burst = NSTAGE;
 204 }
 205
 206 #else
 207 int refclock_tpro_bs;
 208 #endif /* REFCLOCK */