/* * Copyright (c) 1997, 1998 * The Regents of the University of California. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Lawrence Berkeley Laboratory. * 4. The name of the University may not be used to endorse or promote * products derived from this software without specific prior * written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #ifdef HAVE_CONFIG_H # include #endif #if defined(REFCLOCK) && defined(CLOCK_JUPITER) && defined(PPS) #include "ntpd.h" #include "ntp_io.h" #include "ntp_refclock.h" #include "ntp_unixtime.h" #include "ntp_stdlib.h" #include "ntp_calendar.h" #include #include #include "jupiter.h" #include #ifdef XNTP_BIG_ENDIAN #define getshort(s) ((((s) & 0xff) << 8) | (((s) >> 8) & 0xff)) #define putshort(s) ((((s) & 0xff) << 8) | (((s) >> 8) & 0xff)) #else #define getshort(s) (s) #define putshort(s) (s) #endif /* XXX */ #ifdef sun char *strerror(int); #endif /* * This driver supports the Rockwell Jupiter GPS Receiver board * adapted to precision timing applications. It requires the * ppsclock line discipline or streams module described in the * Line Disciplines and Streams Drivers page. It also requires a * gadget box and 1-PPS level converter, such as described in the * Pulse-per-second (PPS) Signal Interfacing page. * * It may work (with minor modifications) with other Rockwell GPS * receivers such as the CityTracker. */ /* * GPS Definitions */ #define DEVICE "/dev/gps%d" /* device name and unit */ #define SPEED232 B9600 /* baud */ /* * The number of raw samples which we acquire to derive a single estimate. * NSAMPLES ideally should not exceed the default poll interval 64. * NKEEP must be a power of 2 to simplify the averaging process. */ #define NSAMPLES 64 #define NKEEP 8 #define REFCLOCKMAXDISPERSE .25 /* max sample dispersion */ /* * Radio interface parameters */ #define PRECISION (-18) /* precision assumed (about 4 us) */ #define REFID "GPS\0" /* reference id */ #define DESCRIPTION "Rockwell Jupiter GPS Receiver" /* who we are */ #define DEFFUDGETIME 0 /* default fudge time (ms) */ /* Unix timestamp for the GPS epoch: January 6, 1980 */ #define GPS_EPOCH 315964800 /* Double short to unsigned int */ #define DS2UI(p) ((getshort((p)[1]) << 16) | getshort((p)[0])) /* Double short to signed int */ #define DS2I(p) ((getshort((p)[1]) << 16) | getshort((p)[0])) /* One week's worth of seconds */ #define WEEKSECS (7 * 24 * 60 * 60) /* * Jupiter unit control structure. */ struct jupiterunit { u_int pollcnt; /* poll message counter */ u_int polled; /* Hand in a time sample? */ u_int lastserial; /* last pps serial number */ struct ppsclockev ppsev; /* PPS control structure */ u_int gweek; /* current GPS week number */ u_int32 lastsweek; /* last seconds into GPS week */ u_int32 timecode; /* current ntp timecode */ u_int32 stime; /* used to detect firmware bug */ int wantid; /* don't reconfig on channel id msg */ u_int moving; /* mobile platform? */ u_long sloppyclockflag; /* fudge flags */ u_int known; /* position known yet? */ int coderecv; /* total received samples */ int nkeep; /* number of samples to preserve */ int rshift; /* number of rshifts for division */ l_fp filter[NSAMPLES]; /* offset filter */ l_fp lastref; /* last reference timestamp */ u_short sbuf[512]; /* local input buffer */ int ssize; /* space used in sbuf */ }; /* * Function prototypes */ static void jupiter_canmsg P((struct peer *, u_int)); static u_short jupiter_cksum P((u_short *, u_int)); #ifdef QSORT_USES_VOID_P int jupiter_cmpl_fp P((const void *, const void *)); #else int jupiter_cmpl_fp P((const l_fp *, const l_fp *)); #endif /* not QSORT_USES_VOID_P */ static void jupiter_config P((struct peer *)); static void jupiter_debug P((struct peer *, char *, ...)) __attribute__ ((format (printf, 2, 3))); static char * jupiter_offset P((struct peer *)); static char * jupiter_parse_t P((struct peer *, u_short *)); static void jupiter_platform P((struct peer *, u_int)); static void jupiter_poll P((int, struct peer *)); static int jupiter_pps P((struct peer *)); static char * jupiter_process P((struct peer *)); static int jupiter_recv P((struct peer *)); static void jupiter_receive P((register struct recvbuf *rbufp)); static void jupiter_reqmsg P((struct peer *, u_int, u_int)); static void jupiter_reqonemsg P((struct peer *, u_int)); static char * jupiter_send P((struct peer *, struct jheader *)); static void jupiter_shutdown P((int, struct peer *)); static int jupiter_start P((int, struct peer *)); static int jupiter_ttyinit P((struct peer *, int)); /* * Transfer vector */ struct refclock refclock_jupiter = { jupiter_start, /* start up driver */ jupiter_shutdown, /* shut down driver */ jupiter_poll, /* transmit poll message */ noentry, /* (clock control) */ noentry, /* (clock init) */ noentry, /* (clock buginfo) */ NOFLAGS /* not used */ }; /* * jupiter_start - open the devices and initialize data for processing */ static int jupiter_start( register int unit, register struct peer *peer ) { struct refclockproc *pp; register struct jupiterunit *up; register int fd; char gpsdev[20]; /* * Open serial port */ (void)sprintf(gpsdev, DEVICE, unit); fd = open(gpsdev, O_RDWR #ifdef O_NONBLOCK | O_NONBLOCK #endif , 0); if (fd < 0) { jupiter_debug(peer, "jupiter_start: open %s: %s\n", gpsdev, strerror(errno)); return (0); } if (!jupiter_ttyinit(peer, fd)) return (0); /* Allocate unit structure */ if ((up = (struct jupiterunit *) emalloc(sizeof(struct jupiterunit))) == NULL) { (void) close(fd); return (0); } memset((char *)up, 0, sizeof(struct jupiterunit)); pp = peer->procptr; pp->io.clock_recv = jupiter_receive; pp->io.srcclock = (caddr_t)peer; pp->io.datalen = 0; pp->io.fd = fd; if (!io_addclock(&pp->io)) { (void) close(fd); free(up); return (0); } pp->unitptr = (caddr_t)up; /* * Initialize miscellaneous variables */ peer->precision = PRECISION; pp->clockdesc = DESCRIPTION; memcpy((char *)&pp->refid, REFID, 4); /* Ensure the receiver is properly configured */ jupiter_config(peer); /* Turn on pulse gathering by requesting the first sample */ if (ioctl(fd, CIOGETEV, (caddr_t)&up->ppsev) < 0) { jupiter_debug(peer, "jupiter_ttyinit: CIOGETEV: %s\n", strerror(errno)); (void) close(fd); free(up); return (0); } up->lastserial = up->ppsev.serial; memset(&up->ppsev, 0, sizeof(up->ppsev)); return (1); } /* * jupiter_shutdown - shut down the clock */ static void jupiter_shutdown(register int unit, register struct peer *peer) { register struct jupiterunit *up; struct refclockproc *pp; pp = peer->procptr; up = (struct jupiterunit *)pp->unitptr; io_closeclock(&pp->io); free(up); } /* * jupiter_config - Configure the receiver */ static void jupiter_config(register struct peer *peer) { register int i; register struct jupiterunit *up; register struct refclockproc *pp; pp = peer->procptr; up = (struct jupiterunit *)pp->unitptr; /* * Initialize the unit variables * * STRANGE BEHAVIOUR WARNING: The fudge flags are not available * at the time jupiter_start is called. These are set later, * and so the code must be prepared to handle changing flags. */ up->sloppyclockflag = pp->sloppyclockflag; if (pp->sloppyclockflag & CLK_FLAG2) { up->moving = 1; /* Receiver on mobile platform */ msyslog(LOG_DEBUG, "jupiter_config: mobile platform"); } else { up->moving = 0; /* Static Installation */ } /* XXX fludge flags don't make the trip from the config to here... */ #ifdef notdef /* Configure for trailing edge triggers */ #ifdef CIOSETTET i = ((pp->sloppyclockflag & CLK_FLAG3) != 0); jupiter_debug(peer, "jupiter_configure: (sloppyclockflag 0x%lx)\n", pp->sloppyclockflag); if (ioctl(pp->io.fd, CIOSETTET, (char *)&i) < 0) msyslog(LOG_DEBUG, "jupiter_configure: CIOSETTET %d: %m", i); #else if (pp->sloppyclockflag & CLK_FLAG3) msyslog(LOG_DEBUG, "jupiter_configure: \ No kernel support for trailing edge trigger"); #endif #endif up->pollcnt = 2; up->polled = 0; up->known = 0; up->gweek = 0; up->lastsweek = 2 * WEEKSECS; up->timecode = 0; up->stime = 0; up->ssize = 0; up->coderecv = 0; up->nkeep = NKEEP; if (up->nkeep > NSAMPLES) up->nkeep = NSAMPLES; if (up->nkeep >= 1) up->rshift = 0; if (up->nkeep >= 2) up->rshift = 1; if (up->nkeep >= 4) up->rshift = 2; if (up->nkeep >= 8) up->rshift = 3; if (up->nkeep >= 16) up->rshift = 4; if (up->nkeep >= 32) up->rshift = 5; if (up->nkeep >= 64) up->rshift = 6; up->nkeep = 1; i = up->rshift; while (i > 0) { up->nkeep *= 2; i--; } /* Stop outputting all messages */ jupiter_canmsg(peer, JUPITER_ALL); /* Request the receiver id so we can syslog the firmware version */ jupiter_reqonemsg(peer, JUPITER_O_ID); /* Flag that this the id was requested (so we don't get called again) */ up->wantid = 1; /* Request perodic time mark pulse messages */ jupiter_reqmsg(peer, JUPITER_O_PULSE, 1); /* Set application platform type */ if (up->moving) jupiter_platform(peer, JUPITER_I_PLAT_MED); else jupiter_platform(peer, JUPITER_I_PLAT_LOW); } /* * jupiter_poll - jupiter watchdog routine */ static void jupiter_poll(register int unit, register struct peer *peer) { register struct jupiterunit *up; register struct refclockproc *pp; pp = peer->procptr; up = (struct jupiterunit *)pp->unitptr; /* * You don't need to poll this clock. It puts out timecodes * once per second. If asked for a timestamp, take note. * The next time a timecode comes in, it will be fed back. */ /* * If we haven't had a response in a while, reset the receiver. */ if (up->pollcnt > 0) { up->pollcnt--; } else { refclock_report(peer, CEVNT_TIMEOUT); /* Request the receiver id to trigger a reconfig */ jupiter_reqonemsg(peer, JUPITER_O_ID); up->wantid = 0; } /* * polled every 64 seconds. Ask jupiter_receive to hand in * a timestamp. */ up->polled = 1; pp->polls++; } /* * jupiter_receive - receive gps data * Gag me! */ static void jupiter_receive(register struct recvbuf *rbufp) { register int bpcnt, cc, size, ppsret; register u_int32 last_timecode, laststime; register char *cp; register u_char *bp; register u_short *sp; register u_long sloppyclockflag; register struct jupiterunit *up; register struct jid *ip; register struct jheader *hp; register struct refclockproc *pp; register struct peer *peer; /* Initialize pointers and read the timecode and timestamp */ peer = (struct peer *)rbufp->recv_srcclock; pp = peer->procptr; up = (struct jupiterunit *)pp->unitptr; /* * If operating mode has been changed, then reinitialize the receiver * before doing anything else. */ /* XXX Sloppy clock flags are broken!! */ sloppyclockflag = up->sloppyclockflag; up->sloppyclockflag = pp->sloppyclockflag; if ((pp->sloppyclockflag & CLK_FLAG2) != (sloppyclockflag & CLK_FLAG2)) { jupiter_debug(peer, "jupiter_receive: mode switch: reset receiver\n"); jupiter_config(peer); return; } up->pollcnt = 2; bp = (u_char *)rbufp->recv_buffer; bpcnt = rbufp->recv_length; /* This shouldn't happen */ if (bpcnt > sizeof(up->sbuf) - up->ssize) bpcnt = sizeof(up->sbuf) - up->ssize; /* Append to input buffer */ memcpy((u_char *)up->sbuf + up->ssize, bp, bpcnt); up->ssize += bpcnt; /* While there's at least a header and we parse a intact message */ while (up->ssize > sizeof(*hp) && (cc = jupiter_recv(peer)) > 0) { hp = (struct jheader *)up->sbuf; sp = (u_short *)(hp + 1); size = cc - sizeof(*hp); switch (getshort(hp->id)) { case JUPITER_O_PULSE: if (size != sizeof(struct jpulse)) { jupiter_debug(peer, "jupiter_receive: pulse: len %d != %u\n", size, (int)sizeof(struct jpulse)); refclock_report(peer, CEVNT_BADREPLY); break; } /* * There appears to be a firmware bug related * to the pulse message; in addition to the one * per second messages, we get an extra pulse * message once an hour (on the anniversary of * the cold start). It seems to come 200 ms * after the one requested. So if we've seen a * pulse message in the last 210 ms, we skip * this one. */ laststime = up->stime; up->stime = DS2UI(((struct jpulse *)sp)->stime); if (laststime != 0 && up->stime - laststime <= 21) { jupiter_debug(peer, "jupiter_receive: \ avoided firmware bug (stime %.2f, laststime %.2f)\n", (double)up->stime * 0.01, (double)laststime * 0.01); break; } /* Retrieve pps timestamp */ ppsret = jupiter_pps(peer); /* Parse timecode (even when there's no pps) */ last_timecode = up->timecode; if ((cp = jupiter_parse_t(peer, sp)) != NULL) { jupiter_debug(peer, "jupiter_receive: pulse: %s\n", cp); break; } /* Bail if we didn't get a pps timestamp */ if (ppsret) break; /* Bail if we don't have the last timecode yet */ if (last_timecode == 0) break; /* Add the new sample to a median filter */ if ((cp = jupiter_offset(peer)) != NULL) { jupiter_debug(peer, "jupiter_receive: offset: %s\n", cp); refclock_report(peer, CEVNT_BADTIME); break; } /* * The clock will blurt a timecode every second * but we only want one when polled. If we * havn't been polled, bail out. */ if (!up->polled) break; /* * It's a live one! Remember this time. */ pp->lasttime = current_time; /* * Determine the reference clock offset and * dispersion. NKEEP of NSAMPLE offsets are * passed through a median filter. * Save the (filtered) offset and dispersion in * pp->offset and pp->disp. */ if ((cp = jupiter_process(peer)) != NULL) { jupiter_debug(peer, "jupiter_receive: process: %s\n", cp); refclock_report(peer, CEVNT_BADTIME); break; } /* * Return offset and dispersion to control * module. We use lastrec as both the reference * time and receive time in order to avoid * being cute, like setting the reference time * later than the receive time, which may cause * a paranoid protocol module to chuck out the * data. */ jupiter_debug(peer, "jupiter_receive: process time: \ %4d-%03d %02d:%02d:%02d at %s, %s\n", pp->year, pp->day, pp->hour, pp->minute, pp->second, prettydate(&pp->lastrec), lfptoa(&pp->offset, 6)); refclock_receive(peer); /* * We have succeeded in answering the poll. * Turn off the flag and return */ up->polled = 0; break; case JUPITER_O_ID: if (size != sizeof(struct jid)) { jupiter_debug(peer, "jupiter_receive: id: len %d != %u\n", size, (int)sizeof(struct jid)); refclock_report(peer, CEVNT_BADREPLY); break; } /* * If we got this message because the Jupiter * just powered up, it needs to be reconfigured. */ ip = (struct jid *)sp; jupiter_debug(peer, "jupiter_receive: >> %s chan ver %s, %s (%s)\n", ip->chans, ip->vers, ip->date, ip->opts); msyslog(LOG_DEBUG, "jupiter_receive: %s chan ver %s, %s (%s)\n", ip->chans, ip->vers, ip->date, ip->opts); if (up->wantid) up->wantid = 0; else { jupiter_debug(peer, "jupiter_receive: reset receiver\n"); jupiter_config(peer); /* Rese since jupiter_config() just zeroed it */ up->ssize = cc; } break; default: jupiter_debug(peer, "jupiter_receive: >> unknown message id %d\n", getshort(hp->id)); break; } up->ssize -= cc; if (up->ssize < 0) { fprintf(stderr, "jupiter_recv: negative ssize!\n"); abort(); } else if (up->ssize > 0) memcpy(up->sbuf, (u_char *)up->sbuf + cc, up->ssize); } record_clock_stats(&peer->srcadr, ""); } /* * jupiter_offset - Calculate the offset, and add to the rolling filter. */ static char * jupiter_offset(register struct peer *peer) { register struct jupiterunit *up; register struct refclockproc *pp; register int i; l_fp offset; pp = peer->procptr; up = (struct jupiterunit *)pp->unitptr; /* * Calculate the offset */ if (!clocktime(pp->day, pp->hour, pp->minute, pp->second, GMT, pp->lastrec.l_ui, &pp->yearstart, &offset.l_ui)) { return ("jupiter_process: clocktime failed"); } if (pp->usec) { TVUTOTSF(pp->usec, offset.l_uf); } else { MSUTOTSF(pp->msec, offset.l_uf); } L_ADD(&offset, &pp->fudgetime1); up->lastref = offset; /* save last reference time */ L_SUB(&offset, &pp->lastrec); /* form true offset */ /* * A rolling filter. Initialize first time around. */ i = ((up->coderecv)) % NSAMPLES; up->filter[i] = offset; if (up->coderecv == 0) for (i = 1; (u_int) i < NSAMPLES; i++) up->filter[i] = up->filter[0]; up->coderecv++; return (NULL); } /* * jupiter_process - process the sample from the clock, * passing it through a median filter and optionally averaging * the samples. Returns offset and dispersion in "up" structure. */ static char * jupiter_process(register struct peer *peer) { register struct jupiterunit *up; register struct refclockproc *pp; register int i, n; register int j, k; l_fp offset, median, lftmp; u_fp disp; l_fp off[NSAMPLES]; pp = peer->procptr; up = (struct jupiterunit *)pp->unitptr; /* * Copy the raw offsets and sort into ascending order */ for (i = 0; i < NSAMPLES; i++) off[i] = up->filter[i]; qsort((char *)off, (size_t)NSAMPLES, sizeof(l_fp), jupiter_cmpl_fp); /* * Reject the furthest from the median of NSAMPLES samples until * NKEEP samples remain. */ i = 0; n = NSAMPLES; while ((n - i) > up->nkeep) { lftmp = off[n - 1]; median = off[(n + i) / 2]; L_SUB(&lftmp, &median); L_SUB(&median, &off[i]); if (L_ISHIS(&median, &lftmp)) { /* reject low end */ i++; } else { /* reject high end */ n--; } } /* * Copy key values to the billboard to measure performance. */ pp->lastref = up->lastref; pp->coderecv = up->coderecv; pp->filter[0] = off[0]; /* smallest offset */ pp->filter[1] = off[NSAMPLES-1]; /* largest offset */ for (j = 2, k = i; k < n; j++, k++) pp->filter[j] = off[k]; /* offsets actually examined */ /* * Compute the dispersion based on the difference between the * extremes of the remaining offsets. Add to this the time since * the last clock update, which represents the dispersion * increase with time. We know that NTP_MAXSKEW is 16. If the * sum is greater than the allowed sample dispersion, bail out. * If the loop is unlocked, return the most recent offset; * otherwise, return the median offset. */ lftmp = off[n - 1]; L_SUB(&lftmp, &off[i]); disp = LFPTOFP(&lftmp); if (disp > REFCLOCKMAXDISPERSE) return ("Maximum dispersion exceeded"); /* * Now compute the offset estimate. If fudge flag 1 * is set, average the remainder, otherwise pick the * median. */ if (pp->sloppyclockflag & CLK_FLAG1) { L_CLR(&lftmp); while (i < n) { L_ADD(&lftmp, &off[i]); i++; } i = up->rshift; while (i > 0) { L_RSHIFT(&lftmp); i--; } offset = lftmp; } else { i = (n + i) / 2; offset = off[i]; } /* * The payload: filtered offset and dispersion. */ pp->offset = offset; pp->disp = disp; return (NULL); } /* Compare two l_fp's, used with qsort() */ #ifdef QSORT_USES_VOID_P int jupiter_cmpl_fp(register const void *p1, register const void *p2) #else int jupiter_cmpl_fp(register const l_fp *fp1, register const l_fp *fp2) #endif { #ifdef QSORT_USES_VOID_P register const l_fp *fp1 = (const l_fp *)p1; register const l_fp *fp2 = (const l_fp *)p2; #endif if (!L_ISGEQ(fp1, fp2)) return (-1); if (L_ISEQU(fp1, fp2)) return (0); return (1); } static char * jupiter_parse_t(register struct peer *peer, register u_short *sp) { register struct refclockproc *pp; register struct jupiterunit *up; register struct tm *tm; register char *cp; register struct jpulse *jp; register struct calendar *jt; register u_int32 sweek; register u_int32 last_timecode; register u_short flags; time_t t; struct calendar cal; pp = peer->procptr; up = (struct jupiterunit *)pp->unitptr; jp = (struct jpulse *)sp; /* The timecode is presented as seconds into the current GPS week */ sweek = DS2UI(jp->sweek); /* * If we don't know the current GPS week, calculate it from the * current time. (It's too bad they didn't include this * important value in the pulse message). We'd like to pick it * up from one of the other messages like gpos or chan but they * don't appear to be synchronous with time keeping and changes * too soon (something like 10 seconds before the new GPS * week). * * If we already know the current GPS week, increment it when * we wrap into a new week. */ if (up->gweek == 0) up->gweek = (time(NULL) - GPS_EPOCH) / WEEKSECS; else if (sweek == 0 && up->lastsweek == WEEKSECS - 1) { ++up->gweek; jupiter_debug(peer, "jupiter_parse_t: NEW gps week %u\n", up->gweek); } /* * See if the sweek stayed the same (this happens when there is * no pps pulse). * * Otherwise, look for time warps: * * - we have stored at least one lastsweek and * - the sweek didn't increase by one and * - we didn't wrap to a new GPS week * * Then we warped. */ if (up->lastsweek == sweek) jupiter_debug(peer, "jupiter_parse_t: gps sweek not incrementing (%d)\n", sweek); else if (up->lastsweek != 2 * WEEKSECS && up->lastsweek + 1 != sweek && !(sweek == 0 && up->lastsweek == WEEKSECS - 1)) jupiter_debug(peer, "jupiter_parse_t: gps sweek jumped (was %d, now %d)\n", up->lastsweek, sweek); up->lastsweek = sweek; /* This timecode describes next pulse */ last_timecode = up->timecode; up->timecode = (u_int32)JAN_1970 + GPS_EPOCH + (up->gweek * WEEKSECS) + sweek; if (last_timecode == 0) /* XXX debugging */ jupiter_debug(peer, "jupiter_parse_t: UTC (gweek/sweek %u/%u)\n", up->gweek, sweek); else { /* XXX debugging */ t = last_timecode - (u_int32)JAN_1970; tm = gmtime(&t); cp = asctime(tm); jupiter_debug(peer, "jupiter_parse_t: UTC %.24s (gweek/sweek %u/%u)\n", cp, up->gweek, sweek); /* Billboard last_timecode (which is now the current time) */ jt = &cal; caljulian(last_timecode, jt); pp = peer->procptr; pp->year = jt->year; pp->day = jt->yearday; pp->hour = jt->hour; pp->minute = jt->minute; pp->second = jt->second; pp->msec = 0; pp->usec = 0; } /* XXX debugging */ tm = gmtime(&up->ppsev.tv.tv_sec); cp = asctime(tm); flags = getshort(jp->flags); jupiter_debug(peer, "jupiter_parse_t: PPS %.19s.%06lu %.4s (serial %u)%s\n", cp, up->ppsev.tv.tv_usec, cp + 20, up->ppsev.serial, (flags & JUPITER_O_PULSE_VALID) == 0 ? " NOT VALID" : ""); /* Toss if not designated "valid" by the gps */ if ((flags & JUPITER_O_PULSE_VALID) == 0) { refclock_report(peer, CEVNT_BADTIME); return ("time mark not valid"); } /* We better be sync'ed to UTC... */ if ((flags & JUPITER_O_PULSE_UTC) == 0) { refclock_report(peer, CEVNT_BADTIME); return ("time mark not sync'ed to UTC"); } return (NULL); } /* * Process a PPS signal, returning a timestamp. */ static int jupiter_pps(register struct peer *peer) { register struct refclockproc *pp; register struct jupiterunit *up; register int firsttime; struct timeval ntp_tv; pp = peer->procptr; up = (struct jupiterunit *)pp->unitptr; /* * Grab the timestamp of the PPS signal. */ firsttime = (up->ppsev.tv.tv_sec == 0); if (ioctl(pp->io.fd, CIOGETEV, (caddr_t)&up->ppsev) < 0) { /* XXX Actually, if this fails, we're pretty much screwed */ jupiter_debug(peer, "jupiter_pps: CIOGETEV: %s\n", strerror(errno)); refclock_report(peer, CEVNT_FAULT); return (1); } /* * Check pps serial number against last one */ if (!firsttime && up->lastserial + 1 != up->ppsev.serial) { if (up->ppsev.serial == up->lastserial) jupiter_debug(peer, "jupiter_pps: no new pps event\n"); else jupiter_debug(peer, "jupiter_pps: missed %d pps events\n", up->ppsev.serial - up->lastserial - 1); up->lastserial = up->ppsev.serial; refclock_report(peer, CEVNT_FAULT); return (1); } up->lastserial = up->ppsev.serial; /* * Return the timestamp in pp->lastrec */ ntp_tv = up->ppsev.tv; ntp_tv.tv_sec += (u_int32)JAN_1970; TVTOTS(&ntp_tv, &pp->lastrec); return (0); } /* * jupiter_debug - print debug messages */ #if defined(__STDC__) static void jupiter_debug(struct peer *peer, char *fmt, ...) #else static void jupiter_debug(peer, fmt, va_alist) struct peer *peer; char *fmt; #endif /* __STDC__ */ { va_list ap; if (debug) { #if defined(__STDC__) va_start(ap, fmt); #else va_start(ap); #endif /* __STDC__ */ /* * Print debug message to stdout * In the future, we may want to get get more creative... */ vfprintf(stderr, fmt, ap); va_end(ap); } } /* Checksum and transmit a message to the Jupiter */ static char * jupiter_send(register struct peer *peer, register struct jheader *hp) { register u_int len, size; register int cc; register u_short *sp; static char errstr[132]; size = sizeof(*hp); hp->hsum = putshort(jupiter_cksum((u_short *)hp, (size / sizeof(u_short)) - 1)); len = getshort(hp->len); if (len > 0) { sp = (u_short *)(hp + 1); sp[len] = putshort(jupiter_cksum(sp, len)); size += (len + 1) * sizeof(u_short); } if ((cc = write(peer->procptr->io.fd, (char *)hp, size)) < 0) { (void)sprintf(errstr, "write: %s", strerror(errno)); return (errstr); } else if (cc != size) { (void)sprintf(errstr, "short write (%d != %d)", cc, size); return (errstr); } return (NULL); } /* Request periodic message output */ static struct { struct jheader jheader; struct jrequest jrequest; } reqmsg = { { putshort(JUPITER_SYNC), 0, putshort((sizeof(struct jrequest) / sizeof(u_short)) - 1), 0, putshort(JUPITER_FLAG_REQUEST | JUPITER_FLAG_NAK | JUPITER_FLAG_CONN | JUPITER_FLAG_LOG), 0 }, { 0, 0, 0, 0 } }; /* An interval of zero means to output on trigger */ static void jupiter_reqmsg(register struct peer *peer, register u_int id, register u_int interval) { register struct jheader *hp; register struct jrequest *rp; register char *cp; hp = &reqmsg.jheader; hp->id = putshort(id); rp = &reqmsg.jrequest; rp->trigger = putshort(interval == 0); rp->interval = putshort(interval); if ((cp = jupiter_send(peer, hp)) != NULL) jupiter_debug(peer, "jupiter_reqmsg: %u: %s\n", id, cp); } /* Cancel periodic message output */ static struct jheader canmsg = { putshort(JUPITER_SYNC), 0, 0, 0, putshort(JUPITER_FLAG_REQUEST | JUPITER_FLAG_NAK | JUPITER_FLAG_DISC), 0 }; static void jupiter_canmsg(register struct peer *peer, register u_int id) { register struct jheader *hp; register char *cp; hp = &canmsg; hp->id = putshort(id); if ((cp = jupiter_send(peer, hp)) != NULL) jupiter_debug(peer, "jupiter_canmsg: %u: %s\n", id, cp); } /* Request a single message output */ static struct jheader reqonemsg = { putshort(JUPITER_SYNC), 0, 0, 0, putshort(JUPITER_FLAG_REQUEST | JUPITER_FLAG_NAK | JUPITER_FLAG_QUERY), 0 }; static void jupiter_reqonemsg(register struct peer *peer, register u_int id) { register struct jheader *hp; register char *cp; hp = &reqonemsg; hp->id = putshort(id); if ((cp = jupiter_send(peer, hp)) != NULL) jupiter_debug(peer, "jupiter_reqonemsg: %u: %s\n", id, cp); } /* Set the platform dynamics */ static struct { struct jheader jheader; struct jplat jplat; } platmsg = { { putshort(JUPITER_SYNC), putshort(JUPITER_I_PLAT), putshort((sizeof(struct jplat) / sizeof(u_short)) - 1), 0, putshort(JUPITER_FLAG_REQUEST | JUPITER_FLAG_NAK), 0 }, { 0, 0, 0 } }; static void jupiter_platform(register struct peer *peer, register u_int platform) { register struct jheader *hp; register struct jplat *pp; register char *cp; hp = &platmsg.jheader; pp = &platmsg.jplat; pp->platform = putshort(platform); if ((cp = jupiter_send(peer, hp)) != NULL) jupiter_debug(peer, "jupiter_platform: %u: %s\n", platform, cp); } /* Checksum "len" shorts */ static u_short jupiter_cksum(register u_short *sp, register u_int len) { register u_short sum, x; sum = 0; while (len-- > 0) { x = *sp++; sum += getshort(x); } return (~sum + 1); } /* Return the size of the next message (or zero if we don't have it all yet) */ static int jupiter_recv(register struct peer *peer) { register int n, len, size, cc; register struct refclockproc *pp; register struct jupiterunit *up; register struct jheader *hp; register u_char *bp; register u_short *sp; pp = peer->procptr; up = (struct jupiterunit *)pp->unitptr; /* Must have at least a header's worth */ cc = sizeof(*hp); size = up->ssize; if (size < cc) return (0); /* Search for the sync short if missing */ sp = up->sbuf; hp = (struct jheader *)sp; if (getshort(hp->sync) != JUPITER_SYNC) { /* Wasn't at the front, sync up */ jupiter_debug(peer, "syncing"); bp = (u_char *)sp; n = size; while (n >= 2) { if (bp[0] != (JUPITER_SYNC & 0xff)) { jupiter_debug(peer, "{0x%x}", bp[0]); ++bp; --n; continue; } if (bp[1] == ((JUPITER_SYNC >> 8) & 0xff)) break; jupiter_debug(peer, "{0x%x 0x%x}", bp[0], bp[1]); bp += 2; n -= 2; } jupiter_debug(peer, "\n"); /* Shuffle data to front of input buffer */ if (n > 0) memcpy(sp, bp, n); size = n; up->ssize = size; if (size < cc || hp->sync != JUPITER_SYNC) return (0); } if (jupiter_cksum(sp, (cc / sizeof(u_short) - 1)) != getshort(hp->hsum)) { jupiter_debug(peer, "jupiter_recv: bad header checksum!\n"); /* This is drastic but checksum errors should be rare */ up->ssize = 0; return (0); } /* Check for a payload */ len = getshort(hp->len); if (len > 0) { n = (len + 1) * sizeof(u_short); /* Not enough data yet */ if (size < cc + n) return (0); /* Check payload checksum */ sp = (u_short *)(hp + 1); if (jupiter_cksum(sp, len) != getshort(sp[len])) { jupiter_debug(peer, "jupiter_recv: bad payload checksum!\n"); /* This is drastic but checksum errors should be rare */ up->ssize = 0; return (0); } cc += n; } return (cc); } static int jupiter_ttyinit(register struct peer *peer, register int fd) { struct termios termios; memset((char *)&termios, 0, sizeof(termios)); if (cfsetispeed(&termios, B9600) < 0 || cfsetospeed(&termios, B9600) < 0) { jupiter_debug(peer, "jupiter_ttyinit: cfsetispeed/cfgetospeed: %s\n", strerror(errno)); return (0); } #ifdef HAVE_CFMAKERAW cfmakeraw(&termios); #else termios.c_iflag &= ~(IMAXBEL | IXOFF | INPCK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IXON | IGNPAR); termios.c_iflag |= IGNBRK; termios.c_oflag &= ~OPOST; termios.c_lflag &= ~(ECHO | ECHOE | ECHOK | ECHONL | ICANON | ISIG | IEXTEN | NOFLSH | TOSTOP | PENDIN); termios.c_cflag &= ~(CSIZE | PARENB); termios.c_cflag |= CS8 | CREAD; termios.c_cc[VMIN] = 1; #endif termios.c_cflag |= CLOCAL; if (tcsetattr(fd, TCSANOW, &termios) < 0) { jupiter_debug(peer, "jupiter_ttyinit: tcsetattr: %s\n", strerror(errno)); return (0); } #ifdef TIOCSPPS if (ioctl(fd, TIOCSPPS, (char *)&fdpps) < 0) { jupiter_debug(peer, "jupiter_ttyinit: TIOCSPPS: %s\n", strerror(errno)); return (0); } #endif #ifdef I_PUSH if (ioctl(fd, I_PUSH, "ppsclock") < 0) { jupiter_debug(peer, "jupiter_ttyinit: push ppsclock: %s\n", strerror(errno)); return (0); } #endif return (1); } #else /* not (REFCLOCK && CLOCK_JUPITER && PPS) */ int refclock_jupiter_bs; #endif /* not (REFCLOCK && CLOCK_JUPITER && PPS) */