1264 lines
33 KiB
C
1264 lines
33 KiB
C
/*
|
|
* 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 <config.h>
|
|
#endif
|
|
|
|
#if defined(REFCLOCK) && defined(CLOCK_JUPITER) && defined(PPS)
|
|
|
|
#include <stdio.h>
|
|
#include <ctype.h>
|
|
#include <sys/time.h>
|
|
|
|
#include "ntpd.h"
|
|
#include "ntp_io.h"
|
|
#include "ntp_refclock.h"
|
|
#include "ntp_unixtime.h"
|
|
#include "ntp_stdlib.h"
|
|
#include "ntp_calendar.h"
|
|
|
|
#include "jupiter.h"
|
|
|
|
#include <sys/ppsclock.h>
|
|
|
|
#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, "<timecode is binary>");
|
|
}
|
|
|
|
/*
|
|
* 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, 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 <none> (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) */
|