Annotation of embedaddon/ntp/ntpd/refclock_jupiter.c, revision 1.1
1.1 ! misho 1: /*
! 2: * Copyright (c) 1997, 1998, 2003
! 3: * The Regents of the University of California. All rights reserved.
! 4: *
! 5: * Redistribution and use in source and binary forms, with or without
! 6: * modification, are permitted provided that the following conditions
! 7: * are met:
! 8: * 1. Redistributions of source code must retain the above copyright
! 9: * notice, this list of conditions and the following disclaimer.
! 10: * 2. Redistributions in binary form must reproduce the above copyright
! 11: * notice, this list of conditions and the following disclaimer in the
! 12: * documentation and/or other materials provided with the distribution.
! 13: * 3. All advertising materials mentioning features or use of this software
! 14: * must display the following acknowledgement:
! 15: * This product includes software developed by the University of
! 16: * California, Lawrence Berkeley Laboratory.
! 17: * 4. The name of the University may not be used to endorse or promote
! 18: * products derived from this software without specific prior
! 19: * written permission.
! 20: *
! 21: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 24: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 31: * SUCH DAMAGE.
! 32: */
! 33:
! 34: #ifdef HAVE_CONFIG_H
! 35: # include <config.h>
! 36: #endif
! 37:
! 38: #if defined(REFCLOCK) && defined(CLOCK_JUPITER) && defined(HAVE_PPSAPI)
! 39:
! 40: #include "ntpd.h"
! 41: #include "ntp_io.h"
! 42: #include "ntp_refclock.h"
! 43: #include "ntp_unixtime.h"
! 44: #include "ntp_stdlib.h"
! 45:
! 46: #include <stdio.h>
! 47: #include <ctype.h>
! 48:
! 49: #include "jupiter.h"
! 50:
! 51: #ifdef HAVE_PPSAPI
! 52: # include "ppsapi_timepps.h"
! 53: #endif
! 54:
! 55: #ifdef XNTP_BIG_ENDIAN
! 56: #define getshort(s) ((((s) & 0xff) << 8) | (((s) >> 8) & 0xff))
! 57: #define putshort(s) ((((s) & 0xff) << 8) | (((s) >> 8) & 0xff))
! 58: #else
! 59: #define getshort(s) (s)
! 60: #define putshort(s) (s)
! 61: #endif
! 62:
! 63: /* XXX */
! 64: #ifdef sun
! 65: char *strerror(int);
! 66: #endif
! 67:
! 68: /*
! 69: * This driver supports the Rockwell Jupiter GPS Receiver board
! 70: * adapted to precision timing applications. It requires the
! 71: * ppsclock line discipline or streams module described in the
! 72: * Line Disciplines and Streams Drivers page. It also requires a
! 73: * gadget box and 1-PPS level converter, such as described in the
! 74: * Pulse-per-second (PPS) Signal Interfacing page.
! 75: *
! 76: * It may work (with minor modifications) with other Rockwell GPS
! 77: * receivers such as the CityTracker.
! 78: */
! 79:
! 80: /*
! 81: * GPS Definitions
! 82: */
! 83: #define DEVICE "/dev/gps%d" /* device name and unit */
! 84: #define SPEED232 B9600 /* baud */
! 85:
! 86: /*
! 87: * Radio interface parameters
! 88: */
! 89: #define PRECISION (-18) /* precision assumed (about 4 us) */
! 90: #define REFID "GPS\0" /* reference id */
! 91: #define DESCRIPTION "Rockwell Jupiter GPS Receiver" /* who we are */
! 92: #define DEFFUDGETIME 0 /* default fudge time (ms) */
! 93:
! 94: /* Unix timestamp for the GPS epoch: January 6, 1980 */
! 95: #define GPS_EPOCH 315964800
! 96:
! 97: /* Double short to unsigned int */
! 98: #define DS2UI(p) ((getshort((p)[1]) << 16) | getshort((p)[0]))
! 99:
! 100: /* Double short to signed int */
! 101: #define DS2I(p) ((getshort((p)[1]) << 16) | getshort((p)[0]))
! 102:
! 103: /* One week's worth of seconds */
! 104: #define WEEKSECS (7 * 24 * 60 * 60)
! 105:
! 106: /*
! 107: * Jupiter unit control structure.
! 108: */
! 109: struct instance {
! 110: struct peer *peer; /* peer */
! 111: u_int pollcnt; /* poll message counter */
! 112: u_int polled; /* Hand in a time sample? */
! 113: #ifdef HAVE_PPSAPI
! 114: pps_params_t pps_params; /* pps parameters */
! 115: pps_info_t pps_info; /* last pps data */
! 116: pps_handle_t pps_handle; /* pps handle */
! 117: u_int assert; /* pps edge to use */
! 118: u_int hardpps; /* enable kernel mode */
! 119: struct timespec ts; /* last timestamp */
! 120: #endif
! 121: l_fp limit;
! 122: u_int gpos_gweek; /* Current GPOS GPS week number */
! 123: u_int gpos_sweek; /* Current GPOS GPS seconds into week */
! 124: u_int gweek; /* current GPS week number */
! 125: u_int32 lastsweek; /* last seconds into GPS week */
! 126: time_t timecode; /* current ntp timecode */
! 127: u_int32 stime; /* used to detect firmware bug */
! 128: int wantid; /* don't reconfig on channel id msg */
! 129: u_int moving; /* mobile platform? */
! 130: u_char sloppyclockflag; /* fudge flags */
! 131: u_short sbuf[512]; /* local input buffer */
! 132: int ssize; /* space used in sbuf */
! 133: };
! 134:
! 135: /*
! 136: * Function prototypes
! 137: */
! 138: static void jupiter_canmsg (struct instance *, u_int);
! 139: static u_short jupiter_cksum (u_short *, u_int);
! 140: static int jupiter_config (struct instance *);
! 141: static void jupiter_debug (struct peer *, char *, char *, ...)
! 142: __attribute__ ((format (printf, 3, 4)));
! 143: static char * jupiter_parse_t (struct instance *, u_short *);
! 144: static char * jupiter_parse_gpos (struct instance *, u_short *);
! 145: static void jupiter_platform (struct instance *, u_int);
! 146: static void jupiter_poll (int, struct peer *);
! 147: static void jupiter_control (int, struct refclockstat *, struct
! 148: refclockstat *, struct peer *);
! 149: #ifdef HAVE_PPSAPI
! 150: static int jupiter_ppsapi (struct instance *);
! 151: static int jupiter_pps (struct instance *);
! 152: #endif /* HAVE_PPSAPI */
! 153: static int jupiter_recv (struct instance *);
! 154: static void jupiter_receive (struct recvbuf *rbufp);
! 155: static void jupiter_reqmsg (struct instance *, u_int, u_int);
! 156: static void jupiter_reqonemsg (struct instance *, u_int);
! 157: static char * jupiter_send (struct instance *, struct jheader *);
! 158: static void jupiter_shutdown (int, struct peer *);
! 159: static int jupiter_start (int, struct peer *);
! 160:
! 161: /*
! 162: * Transfer vector
! 163: */
! 164: struct refclock refclock_jupiter = {
! 165: jupiter_start, /* start up driver */
! 166: jupiter_shutdown, /* shut down driver */
! 167: jupiter_poll, /* transmit poll message */
! 168: jupiter_control, /* (clock control) */
! 169: noentry, /* (clock init) */
! 170: noentry, /* (clock buginfo) */
! 171: NOFLAGS /* not used */
! 172: };
! 173:
! 174: /*
! 175: * jupiter_start - open the devices and initialize data for processing
! 176: */
! 177: static int
! 178: jupiter_start(
! 179: int unit,
! 180: struct peer *peer
! 181: )
! 182: {
! 183: struct refclockproc *pp;
! 184: struct instance *instance;
! 185: int fd = -1;
! 186: char gpsdev[20];
! 187:
! 188: /*
! 189: * Open serial port
! 190: */
! 191: snprintf(gpsdev, sizeof(gpsdev), DEVICE, unit);
! 192: fd = refclock_open(gpsdev, SPEED232, LDISC_RAW);
! 193: if (fd == 0) {
! 194: jupiter_debug(peer, "jupiter_start", "open %s: %s",
! 195: gpsdev, strerror(errno));
! 196: return (0);
! 197: }
! 198:
! 199: /* Allocate unit structure */
! 200: instance = emalloc(sizeof(*instance));
! 201: memset(instance, 0, sizeof(*instance));
! 202: instance->peer = peer;
! 203: pp = peer->procptr;
! 204: pp->io.clock_recv = jupiter_receive;
! 205: pp->io.srcclock = (caddr_t)peer;
! 206: pp->io.datalen = 0;
! 207: pp->io.fd = fd;
! 208: if (!io_addclock(&pp->io)) {
! 209: close(fd);
! 210: free(instance);
! 211: return (0);
! 212: }
! 213: pp->unitptr = (caddr_t)instance;
! 214:
! 215: /*
! 216: * Initialize miscellaneous variables
! 217: */
! 218: peer->precision = PRECISION;
! 219: pp->clockdesc = DESCRIPTION;
! 220: memcpy((char *)&pp->refid, REFID, 4);
! 221:
! 222: #ifdef HAVE_PPSAPI
! 223: instance->assert = 1;
! 224: instance->hardpps = 0;
! 225: /*
! 226: * Start the PPSAPI interface if it is there. Default to use
! 227: * the assert edge and do not enable the kernel hardpps.
! 228: */
! 229: if (time_pps_create(fd, &instance->pps_handle) < 0) {
! 230: instance->pps_handle = 0;
! 231: msyslog(LOG_ERR,
! 232: "refclock_jupiter: time_pps_create failed: %m");
! 233: }
! 234: else if (!jupiter_ppsapi(instance))
! 235: goto clean_up;
! 236: #endif /* HAVE_PPSAPI */
! 237:
! 238: /* Ensure the receiver is properly configured */
! 239: if (!jupiter_config(instance))
! 240: goto clean_up;
! 241:
! 242: return (1);
! 243:
! 244: clean_up:
! 245: jupiter_shutdown(unit, peer);
! 246: pp->unitptr = 0;
! 247: return (0);
! 248: }
! 249:
! 250: /*
! 251: * jupiter_shutdown - shut down the clock
! 252: */
! 253: static void
! 254: jupiter_shutdown(int unit, struct peer *peer)
! 255: {
! 256: struct instance *instance;
! 257: struct refclockproc *pp;
! 258:
! 259: pp = peer->procptr;
! 260: instance = (struct instance *)pp->unitptr;
! 261: if (!instance)
! 262: return;
! 263:
! 264: #ifdef HAVE_PPSAPI
! 265: if (instance->pps_handle) {
! 266: time_pps_destroy(instance->pps_handle);
! 267: instance->pps_handle = 0;
! 268: }
! 269: #endif /* HAVE_PPSAPI */
! 270:
! 271: io_closeclock(&pp->io);
! 272: free(instance);
! 273: }
! 274:
! 275: /*
! 276: * jupiter_config - Configure the receiver
! 277: */
! 278: static int
! 279: jupiter_config(struct instance *instance)
! 280: {
! 281: jupiter_debug(instance->peer, "jupiter_config", "init receiver");
! 282:
! 283: /*
! 284: * Initialize the unit variables
! 285: */
! 286: instance->sloppyclockflag = instance->peer->procptr->sloppyclockflag;
! 287: instance->moving = !!(instance->sloppyclockflag & CLK_FLAG2);
! 288: if (instance->moving)
! 289: jupiter_debug(instance->peer, "jupiter_config",
! 290: "mobile platform");
! 291:
! 292: instance->pollcnt = 2;
! 293: instance->polled = 0;
! 294: instance->gpos_gweek = 0;
! 295: instance->gpos_sweek = 0;
! 296: instance->gweek = 0;
! 297: instance->lastsweek = 2 * WEEKSECS;
! 298: instance->timecode = 0;
! 299: instance->stime = 0;
! 300: instance->ssize = 0;
! 301:
! 302: /* Stop outputting all messages */
! 303: jupiter_canmsg(instance, JUPITER_ALL);
! 304:
! 305: /* Request the receiver id so we can syslog the firmware version */
! 306: jupiter_reqonemsg(instance, JUPITER_O_ID);
! 307:
! 308: /* Flag that this the id was requested (so we don't get called again) */
! 309: instance->wantid = 1;
! 310:
! 311: /* Request perodic time mark pulse messages */
! 312: jupiter_reqmsg(instance, JUPITER_O_PULSE, 1);
! 313:
! 314: /* Request perodic geodetic position status */
! 315: jupiter_reqmsg(instance, JUPITER_O_GPOS, 1);
! 316:
! 317: /* Set application platform type */
! 318: if (instance->moving)
! 319: jupiter_platform(instance, JUPITER_I_PLAT_MED);
! 320: else
! 321: jupiter_platform(instance, JUPITER_I_PLAT_LOW);
! 322:
! 323: return (1);
! 324: }
! 325:
! 326: #ifdef HAVE_PPSAPI
! 327: /*
! 328: * Initialize PPSAPI
! 329: */
! 330: int
! 331: jupiter_ppsapi(
! 332: struct instance *instance /* unit structure pointer */
! 333: )
! 334: {
! 335: int capability;
! 336:
! 337: if (time_pps_getcap(instance->pps_handle, &capability) < 0) {
! 338: msyslog(LOG_ERR,
! 339: "refclock_jupiter: time_pps_getcap failed: %m");
! 340: return (0);
! 341: }
! 342: memset(&instance->pps_params, 0, sizeof(pps_params_t));
! 343: if (!instance->assert)
! 344: instance->pps_params.mode = capability & PPS_CAPTURECLEAR;
! 345: else
! 346: instance->pps_params.mode = capability & PPS_CAPTUREASSERT;
! 347: if (!(instance->pps_params.mode & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR))) {
! 348: msyslog(LOG_ERR,
! 349: "refclock_jupiter: invalid capture edge %d",
! 350: instance->assert);
! 351: return (0);
! 352: }
! 353: instance->pps_params.mode |= PPS_TSFMT_TSPEC;
! 354: if (time_pps_setparams(instance->pps_handle, &instance->pps_params) < 0) {
! 355: msyslog(LOG_ERR,
! 356: "refclock_jupiter: time_pps_setparams failed: %m");
! 357: return (0);
! 358: }
! 359: if (instance->hardpps) {
! 360: if (time_pps_kcbind(instance->pps_handle, PPS_KC_HARDPPS,
! 361: instance->pps_params.mode & ~PPS_TSFMT_TSPEC,
! 362: PPS_TSFMT_TSPEC) < 0) {
! 363: msyslog(LOG_ERR,
! 364: "refclock_jupiter: time_pps_kcbind failed: %m");
! 365: return (0);
! 366: }
! 367: pps_enable = 1;
! 368: }
! 369: /* instance->peer->precision = PPS_PRECISION; */
! 370:
! 371: #if DEBUG
! 372: if (debug) {
! 373: time_pps_getparams(instance->pps_handle, &instance->pps_params);
! 374: jupiter_debug(instance->peer, "refclock_jupiter",
! 375: "pps capability 0x%x version %d mode 0x%x kern %d",
! 376: capability, instance->pps_params.api_version,
! 377: instance->pps_params.mode, instance->hardpps);
! 378: }
! 379: #endif
! 380:
! 381: return (1);
! 382: }
! 383:
! 384: /*
! 385: * Get PPSAPI timestamps.
! 386: *
! 387: * Return 0 on failure and 1 on success.
! 388: */
! 389: static int
! 390: jupiter_pps(struct instance *instance)
! 391: {
! 392: pps_info_t pps_info;
! 393: struct timespec timeout, ts;
! 394: double dtemp;
! 395: l_fp tstmp;
! 396:
! 397: /*
! 398: * Convert the timespec nanoseconds field to ntp l_fp units.
! 399: */
! 400: if (instance->pps_handle == 0)
! 401: return 1;
! 402: timeout.tv_sec = 0;
! 403: timeout.tv_nsec = 0;
! 404: memcpy(&pps_info, &instance->pps_info, sizeof(pps_info_t));
! 405: if (time_pps_fetch(instance->pps_handle, PPS_TSFMT_TSPEC, &instance->pps_info,
! 406: &timeout) < 0)
! 407: return 1;
! 408: if (instance->pps_params.mode & PPS_CAPTUREASSERT) {
! 409: if (pps_info.assert_sequence ==
! 410: instance->pps_info.assert_sequence)
! 411: return 1;
! 412: ts = instance->pps_info.assert_timestamp;
! 413: } else if (instance->pps_params.mode & PPS_CAPTURECLEAR) {
! 414: if (pps_info.clear_sequence ==
! 415: instance->pps_info.clear_sequence)
! 416: return 1;
! 417: ts = instance->pps_info.clear_timestamp;
! 418: } else {
! 419: return 1;
! 420: }
! 421: if ((instance->ts.tv_sec == ts.tv_sec) && (instance->ts.tv_nsec == ts.tv_nsec))
! 422: return 1;
! 423: instance->ts = ts;
! 424:
! 425: tstmp.l_ui = ts.tv_sec + JAN_1970;
! 426: dtemp = ts.tv_nsec * FRAC / 1e9;
! 427: tstmp.l_uf = (u_int32)dtemp;
! 428: instance->peer->procptr->lastrec = tstmp;
! 429: return 0;
! 430: }
! 431: #endif /* HAVE_PPSAPI */
! 432:
! 433: /*
! 434: * jupiter_poll - jupiter watchdog routine
! 435: */
! 436: static void
! 437: jupiter_poll(int unit, struct peer *peer)
! 438: {
! 439: struct instance *instance;
! 440: struct refclockproc *pp;
! 441:
! 442: pp = peer->procptr;
! 443: instance = (struct instance *)pp->unitptr;
! 444:
! 445: /*
! 446: * You don't need to poll this clock. It puts out timecodes
! 447: * once per second. If asked for a timestamp, take note.
! 448: * The next time a timecode comes in, it will be fed back.
! 449: */
! 450:
! 451: /*
! 452: * If we haven't had a response in a while, reset the receiver.
! 453: */
! 454: if (instance->pollcnt > 0) {
! 455: instance->pollcnt--;
! 456: } else {
! 457: refclock_report(peer, CEVNT_TIMEOUT);
! 458:
! 459: /* Request the receiver id to trigger a reconfig */
! 460: jupiter_reqonemsg(instance, JUPITER_O_ID);
! 461: instance->wantid = 0;
! 462: }
! 463:
! 464: /*
! 465: * polled every 64 seconds. Ask jupiter_receive to hand in
! 466: * a timestamp.
! 467: */
! 468: instance->polled = 1;
! 469: pp->polls++;
! 470: }
! 471:
! 472: /*
! 473: * jupiter_control - fudge control
! 474: */
! 475: static void
! 476: jupiter_control(
! 477: int unit, /* unit (not used) */
! 478: struct refclockstat *in, /* input parameters (not used) */
! 479: struct refclockstat *out, /* output parameters (not used) */
! 480: struct peer *peer /* peer structure pointer */
! 481: )
! 482: {
! 483: struct refclockproc *pp;
! 484: struct instance *instance;
! 485: u_char sloppyclockflag;
! 486:
! 487: pp = peer->procptr;
! 488: instance = (struct instance *)pp->unitptr;
! 489:
! 490: DTOLFP(pp->fudgetime2, &instance->limit);
! 491: /* Force positive value. */
! 492: if (L_ISNEG(&instance->limit))
! 493: L_NEG(&instance->limit);
! 494:
! 495: #ifdef HAVE_PPSAPI
! 496: instance->assert = !(pp->sloppyclockflag & CLK_FLAG3);
! 497: jupiter_ppsapi(instance);
! 498: #endif /* HAVE_PPSAPI */
! 499:
! 500: sloppyclockflag = instance->sloppyclockflag;
! 501: instance->sloppyclockflag = pp->sloppyclockflag;
! 502: if ((instance->sloppyclockflag & CLK_FLAG2) !=
! 503: (sloppyclockflag & CLK_FLAG2)) {
! 504: jupiter_debug(peer,
! 505: "jupiter_control",
! 506: "mode switch: reset receiver");
! 507: jupiter_config(instance);
! 508: return;
! 509: }
! 510: }
! 511:
! 512: /*
! 513: * jupiter_receive - receive gps data
! 514: * Gag me!
! 515: */
! 516: static void
! 517: jupiter_receive(struct recvbuf *rbufp)
! 518: {
! 519: int bpcnt, cc, size, ppsret;
! 520: time_t last_timecode;
! 521: u_int32 laststime;
! 522: char *cp;
! 523: u_char *bp;
! 524: u_short *sp;
! 525: struct jid *ip;
! 526: struct jheader *hp;
! 527: struct peer *peer;
! 528: struct refclockproc *pp;
! 529: struct instance *instance;
! 530: l_fp tstamp;
! 531:
! 532: /* Initialize pointers and read the timecode and timestamp */
! 533: peer = (struct peer *)rbufp->recv_srcclock;
! 534: pp = peer->procptr;
! 535: instance = (struct instance *)pp->unitptr;
! 536:
! 537: bp = (u_char *)rbufp->recv_buffer;
! 538: bpcnt = rbufp->recv_length;
! 539:
! 540: /* This shouldn't happen */
! 541: if (bpcnt > sizeof(instance->sbuf) - instance->ssize)
! 542: bpcnt = sizeof(instance->sbuf) - instance->ssize;
! 543:
! 544: /* Append to input buffer */
! 545: memcpy((u_char *)instance->sbuf + instance->ssize, bp, bpcnt);
! 546: instance->ssize += bpcnt;
! 547:
! 548: /* While there's at least a header and we parse an intact message */
! 549: while (instance->ssize > sizeof(*hp) && (cc = jupiter_recv(instance)) > 0) {
! 550: instance->pollcnt = 2;
! 551:
! 552: tstamp = rbufp->recv_time;
! 553: hp = (struct jheader *)instance->sbuf;
! 554: sp = (u_short *)(hp + 1);
! 555: size = cc - sizeof(*hp);
! 556: switch (getshort(hp->id)) {
! 557:
! 558: case JUPITER_O_PULSE:
! 559: if (size != sizeof(struct jpulse)) {
! 560: jupiter_debug(peer,
! 561: "jupiter_receive", "pulse: len %d != %u",
! 562: size, (int)sizeof(struct jpulse));
! 563: refclock_report(peer, CEVNT_BADREPLY);
! 564: break;
! 565: }
! 566:
! 567: /*
! 568: * There appears to be a firmware bug related
! 569: * to the pulse message; in addition to the one
! 570: * per second messages, we get an extra pulse
! 571: * message once an hour (on the anniversary of
! 572: * the cold start). It seems to come 200 ms
! 573: * after the one requested. So if we've seen a
! 574: * pulse message in the last 210 ms, we skip
! 575: * this one.
! 576: */
! 577: laststime = instance->stime;
! 578: instance->stime = DS2UI(((struct jpulse *)sp)->stime);
! 579: if (laststime != 0 && instance->stime - laststime <= 21) {
! 580: jupiter_debug(peer, "jupiter_receive",
! 581: "avoided firmware bug (stime %.2f, laststime %.2f)",
! 582: (double)instance->stime * 0.01, (double)laststime * 0.01);
! 583: break;
! 584: }
! 585:
! 586: /* Retrieve pps timestamp */
! 587: ppsret = jupiter_pps(instance);
! 588:
! 589: /*
! 590: * Add one second if msg received early
! 591: * (i.e. before limit, a.k.a. fudgetime2) in
! 592: * the second.
! 593: */
! 594: L_SUB(&tstamp, &pp->lastrec);
! 595: if (!L_ISGEQ(&tstamp, &instance->limit))
! 596: ++pp->lastrec.l_ui;
! 597:
! 598: /* Parse timecode (even when there's no pps) */
! 599: last_timecode = instance->timecode;
! 600: if ((cp = jupiter_parse_t(instance, sp)) != NULL) {
! 601: jupiter_debug(peer,
! 602: "jupiter_receive", "pulse: %s", cp);
! 603: break;
! 604: }
! 605:
! 606: /* Bail if we didn't get a pps timestamp */
! 607: if (ppsret)
! 608: break;
! 609:
! 610: /* Bail if we don't have the last timecode yet */
! 611: if (last_timecode == 0)
! 612: break;
! 613:
! 614: /* Add the new sample to a median filter */
! 615: tstamp.l_ui = JAN_1970 + last_timecode;
! 616: tstamp.l_uf = 0;
! 617:
! 618: refclock_process_offset(pp, tstamp, pp->lastrec, pp->fudgetime1);
! 619:
! 620: /*
! 621: * The clock will blurt a timecode every second
! 622: * but we only want one when polled. If we
! 623: * havn't been polled, bail out.
! 624: */
! 625: if (!instance->polled)
! 626: break;
! 627: instance->polled = 0;
! 628:
! 629: /*
! 630: * It's a live one! Remember this time.
! 631: */
! 632:
! 633: pp->lastref = pp->lastrec;
! 634: refclock_receive(peer);
! 635:
! 636: /*
! 637: * If we get here - what we got from the clock is
! 638: * OK, so say so
! 639: */
! 640: refclock_report(peer, CEVNT_NOMINAL);
! 641:
! 642: /*
! 643: * We have succeeded in answering the poll.
! 644: * Turn off the flag and return
! 645: */
! 646: instance->polled = 0;
! 647: break;
! 648:
! 649: case JUPITER_O_GPOS:
! 650: if (size != sizeof(struct jgpos)) {
! 651: jupiter_debug(peer,
! 652: "jupiter_receive", "gpos: len %d != %u",
! 653: size, (int)sizeof(struct jgpos));
! 654: refclock_report(peer, CEVNT_BADREPLY);
! 655: break;
! 656: }
! 657:
! 658: if ((cp = jupiter_parse_gpos(instance, sp)) != NULL) {
! 659: jupiter_debug(peer,
! 660: "jupiter_receive", "gpos: %s", cp);
! 661: break;
! 662: }
! 663: break;
! 664:
! 665: case JUPITER_O_ID:
! 666: if (size != sizeof(struct jid)) {
! 667: jupiter_debug(peer,
! 668: "jupiter_receive", "id: len %d != %u",
! 669: size, (int)sizeof(struct jid));
! 670: refclock_report(peer, CEVNT_BADREPLY);
! 671: break;
! 672: }
! 673: /*
! 674: * If we got this message because the Jupiter
! 675: * just powered instance, it needs to be reconfigured.
! 676: */
! 677: ip = (struct jid *)sp;
! 678: jupiter_debug(peer,
! 679: "jupiter_receive", "%s chan ver %s, %s (%s)",
! 680: ip->chans, ip->vers, ip->date, ip->opts);
! 681: msyslog(LOG_DEBUG,
! 682: "jupiter_receive: %s chan ver %s, %s (%s)",
! 683: ip->chans, ip->vers, ip->date, ip->opts);
! 684: if (instance->wantid)
! 685: instance->wantid = 0;
! 686: else {
! 687: jupiter_debug(peer,
! 688: "jupiter_receive", "reset receiver");
! 689: jupiter_config(instance);
! 690: /*
! 691: * Restore since jupiter_config() just
! 692: * zeroed it
! 693: */
! 694: instance->ssize = cc;
! 695: }
! 696: break;
! 697:
! 698: default:
! 699: jupiter_debug(peer,
! 700: "jupiter_receive", "unknown message id %d",
! 701: getshort(hp->id));
! 702: break;
! 703: }
! 704: instance->ssize -= cc;
! 705: if (instance->ssize < 0) {
! 706: fprintf(stderr, "jupiter_recv: negative ssize!\n");
! 707: abort();
! 708: } else if (instance->ssize > 0)
! 709: memcpy(instance->sbuf, (u_char *)instance->sbuf + cc, instance->ssize);
! 710: }
! 711: }
! 712:
! 713: static char *
! 714: jupiter_parse_t(struct instance *instance, u_short *sp)
! 715: {
! 716: struct tm *tm;
! 717: char *cp;
! 718: struct jpulse *jp;
! 719: u_int32 sweek;
! 720: time_t last_timecode;
! 721: u_short flags;
! 722:
! 723: jp = (struct jpulse *)sp;
! 724:
! 725: /* The timecode is presented as seconds into the current GPS week */
! 726: sweek = DS2UI(jp->sweek) % WEEKSECS;
! 727:
! 728: /*
! 729: * If we don't know the current GPS week, calculate it from the
! 730: * current time. (It's too bad they didn't include this
! 731: * important value in the pulse message). We'd like to pick it
! 732: * up from one of the other messages like gpos or chan but they
! 733: * don't appear to be synchronous with time keeping and changes
! 734: * too soon (something like 10 seconds before the new GPS
! 735: * week).
! 736: *
! 737: * If we already know the current GPS week, increment it when
! 738: * we wrap into a new week.
! 739: */
! 740: if (instance->gweek == 0) {
! 741: if (!instance->gpos_gweek) {
! 742: return ("jupiter_parse_t: Unknown gweek");
! 743: }
! 744:
! 745: instance->gweek = instance->gpos_gweek;
! 746:
! 747: /*
! 748: * Fix warps. GPOS has GPS time and PULSE has UTC.
! 749: * Plus, GPOS need not be completely in synch with
! 750: * the PPS signal.
! 751: */
! 752: if (instance->gpos_sweek >= sweek) {
! 753: if ((instance->gpos_sweek - sweek) > WEEKSECS / 2)
! 754: ++instance->gweek;
! 755: }
! 756: else {
! 757: if ((sweek - instance->gpos_sweek) > WEEKSECS / 2)
! 758: --instance->gweek;
! 759: }
! 760: }
! 761: else if (sweek == 0 && instance->lastsweek == WEEKSECS - 1) {
! 762: ++instance->gweek;
! 763: jupiter_debug(instance->peer,
! 764: "jupiter_parse_t", "NEW gps week %u", instance->gweek);
! 765: }
! 766:
! 767: /*
! 768: * See if the sweek stayed the same (this happens when there is
! 769: * no pps pulse).
! 770: *
! 771: * Otherwise, look for time warps:
! 772: *
! 773: * - we have stored at least one lastsweek and
! 774: * - the sweek didn't increase by one and
! 775: * - we didn't wrap to a new GPS week
! 776: *
! 777: * Then we warped.
! 778: */
! 779: if (instance->lastsweek == sweek)
! 780: jupiter_debug(instance->peer,
! 781: "jupiter_parse_t", "gps sweek not incrementing (%d)",
! 782: sweek);
! 783: else if (instance->lastsweek != 2 * WEEKSECS &&
! 784: instance->lastsweek + 1 != sweek &&
! 785: !(sweek == 0 && instance->lastsweek == WEEKSECS - 1))
! 786: jupiter_debug(instance->peer,
! 787: "jupiter_parse_t", "gps sweek jumped (was %d, now %d)",
! 788: instance->lastsweek, sweek);
! 789: instance->lastsweek = sweek;
! 790:
! 791: /* This timecode describes next pulse */
! 792: last_timecode = instance->timecode;
! 793: instance->timecode =
! 794: GPS_EPOCH + (instance->gweek * WEEKSECS) + sweek;
! 795:
! 796: if (last_timecode == 0)
! 797: /* XXX debugging */
! 798: jupiter_debug(instance->peer,
! 799: "jupiter_parse_t", "UTC <none> (gweek/sweek %u/%u)",
! 800: instance->gweek, sweek);
! 801: else {
! 802: /* XXX debugging */
! 803: tm = gmtime(&last_timecode);
! 804: cp = asctime(tm);
! 805:
! 806: jupiter_debug(instance->peer,
! 807: "jupiter_parse_t", "UTC %.24s (gweek/sweek %u/%u)",
! 808: cp, instance->gweek, sweek);
! 809:
! 810: /* Billboard last_timecode (which is now the current time) */
! 811: instance->peer->procptr->year = tm->tm_year + 1900;
! 812: instance->peer->procptr->day = tm->tm_yday + 1;
! 813: instance->peer->procptr->hour = tm->tm_hour;
! 814: instance->peer->procptr->minute = tm->tm_min;
! 815: instance->peer->procptr->second = tm->tm_sec;
! 816: }
! 817:
! 818: flags = getshort(jp->flags);
! 819:
! 820: /* Toss if not designated "valid" by the gps */
! 821: if ((flags & JUPITER_O_PULSE_VALID) == 0) {
! 822: refclock_report(instance->peer, CEVNT_BADTIME);
! 823: return ("time mark not valid");
! 824: }
! 825:
! 826: /* We better be sync'ed to UTC... */
! 827: if ((flags & JUPITER_O_PULSE_UTC) == 0) {
! 828: refclock_report(instance->peer, CEVNT_BADTIME);
! 829: return ("time mark not sync'ed to UTC");
! 830: }
! 831:
! 832: return (NULL);
! 833: }
! 834:
! 835: static char *
! 836: jupiter_parse_gpos(struct instance *instance, u_short *sp)
! 837: {
! 838: struct jgpos *jg;
! 839: time_t t;
! 840: struct tm *tm;
! 841: char *cp;
! 842:
! 843: jg = (struct jgpos *)sp;
! 844:
! 845: if (jg->navval != 0) {
! 846: /*
! 847: * Solution not valid. Use caution and refuse
! 848: * to determine GPS week from this message.
! 849: */
! 850: instance->gpos_gweek = 0;
! 851: instance->gpos_sweek = 0;
! 852: return ("Navigation solution not valid");
! 853: }
! 854:
! 855: instance->gpos_gweek = jg->gweek;
! 856: instance->gpos_sweek = DS2UI(jg->sweek);
! 857: while(instance->gpos_sweek >= WEEKSECS) {
! 858: instance->gpos_sweek -= WEEKSECS;
! 859: ++instance->gpos_gweek;
! 860: }
! 861: instance->gweek = 0;
! 862:
! 863: t = GPS_EPOCH + (instance->gpos_gweek * WEEKSECS) + instance->gpos_sweek;
! 864: tm = gmtime(&t);
! 865: cp = asctime(tm);
! 866:
! 867: jupiter_debug(instance->peer,
! 868: "jupiter_parse_g", "GPS %.24s (gweek/sweek %u/%u)",
! 869: cp, instance->gpos_gweek, instance->gpos_sweek);
! 870: return (NULL);
! 871: }
! 872:
! 873: /*
! 874: * jupiter_debug - print debug messages
! 875: */
! 876: #if defined(__STDC__) || defined(SYS_WINNT)
! 877: static void
! 878: jupiter_debug(struct peer *peer, char *function, char *fmt, ...)
! 879: #else
! 880: static void
! 881: jupiter_debug(peer, function, fmt, va_alist)
! 882: struct peer *peer;
! 883: char *function;
! 884: char *fmt;
! 885: #endif /* __STDC__ */
! 886: {
! 887: char buffer[200];
! 888: va_list ap;
! 889:
! 890: #if defined(__STDC__) || defined(SYS_WINNT)
! 891: va_start(ap, fmt);
! 892: #else
! 893: va_start(ap);
! 894: #endif /* __STDC__ */
! 895: /*
! 896: * Print debug message to stdout
! 897: * In the future, we may want to get get more creative...
! 898: */
! 899: vsnprintf(buffer, sizeof(buffer), fmt, ap);
! 900: record_clock_stats(&(peer->srcadr), buffer);
! 901: #ifdef DEBUG
! 902: if (debug) {
! 903: fprintf(stdout, "%s: ", function);
! 904: fprintf(stdout, buffer);
! 905: fprintf(stdout, "\n");
! 906: fflush(stdout);
! 907: }
! 908: #endif
! 909:
! 910: va_end(ap);
! 911: }
! 912:
! 913: /* Checksum and transmit a message to the Jupiter */
! 914: static char *
! 915: jupiter_send(struct instance *instance, struct jheader *hp)
! 916: {
! 917: u_int len, size;
! 918: int cc;
! 919: u_short *sp;
! 920: static char errstr[132];
! 921:
! 922: size = sizeof(*hp);
! 923: hp->hsum = putshort(jupiter_cksum((u_short *)hp,
! 924: (size / sizeof(u_short)) - 1));
! 925: len = getshort(hp->len);
! 926: if (len > 0) {
! 927: sp = (u_short *)(hp + 1);
! 928: sp[len] = putshort(jupiter_cksum(sp, len));
! 929: size += (len + 1) * sizeof(u_short);
! 930: }
! 931:
! 932: if ((cc = write(instance->peer->procptr->io.fd, (char *)hp, size)) < 0) {
! 933: snprintf(errstr, sizeof(errstr), "write: %s", strerror(errno));
! 934: return (errstr);
! 935: } else if (cc != size) {
! 936: snprintf(errstr, sizeof(errstr), "short write (%d != %d)", cc, size);
! 937: return (errstr);
! 938: }
! 939: return (NULL);
! 940: }
! 941:
! 942: /* Request periodic message output */
! 943: static struct {
! 944: struct jheader jheader;
! 945: struct jrequest jrequest;
! 946: } reqmsg = {
! 947: { putshort(JUPITER_SYNC), 0,
! 948: putshort((sizeof(struct jrequest) / sizeof(u_short)) - 1),
! 949: 0, JUPITER_FLAG_REQUEST | JUPITER_FLAG_NAK |
! 950: JUPITER_FLAG_CONN | JUPITER_FLAG_LOG, 0 },
! 951: { 0, 0, 0, 0 }
! 952: };
! 953:
! 954: /* An interval of zero means to output on trigger */
! 955: static void
! 956: jupiter_reqmsg(struct instance *instance, u_int id,
! 957: u_int interval)
! 958: {
! 959: struct jheader *hp;
! 960: struct jrequest *rp;
! 961: char *cp;
! 962:
! 963: hp = &reqmsg.jheader;
! 964: hp->id = putshort(id);
! 965: rp = &reqmsg.jrequest;
! 966: rp->trigger = putshort(interval == 0);
! 967: rp->interval = putshort(interval);
! 968: if ((cp = jupiter_send(instance, hp)) != NULL)
! 969: jupiter_debug(instance->peer, "jupiter_reqmsg", "%u: %s", id, cp);
! 970: }
! 971:
! 972: /* Cancel periodic message output */
! 973: static struct jheader canmsg = {
! 974: putshort(JUPITER_SYNC), 0, 0, 0,
! 975: JUPITER_FLAG_REQUEST | JUPITER_FLAG_NAK | JUPITER_FLAG_DISC,
! 976: 0
! 977: };
! 978:
! 979: static void
! 980: jupiter_canmsg(struct instance *instance, u_int id)
! 981: {
! 982: struct jheader *hp;
! 983: char *cp;
! 984:
! 985: hp = &canmsg;
! 986: hp->id = putshort(id);
! 987: if ((cp = jupiter_send(instance, hp)) != NULL)
! 988: jupiter_debug(instance->peer, "jupiter_canmsg", "%u: %s", id, cp);
! 989: }
! 990:
! 991: /* Request a single message output */
! 992: static struct jheader reqonemsg = {
! 993: putshort(JUPITER_SYNC), 0, 0, 0,
! 994: JUPITER_FLAG_REQUEST | JUPITER_FLAG_NAK | JUPITER_FLAG_QUERY,
! 995: 0
! 996: };
! 997:
! 998: static void
! 999: jupiter_reqonemsg(struct instance *instance, u_int id)
! 1000: {
! 1001: struct jheader *hp;
! 1002: char *cp;
! 1003:
! 1004: hp = &reqonemsg;
! 1005: hp->id = putshort(id);
! 1006: if ((cp = jupiter_send(instance, hp)) != NULL)
! 1007: jupiter_debug(instance->peer, "jupiter_reqonemsg", "%u: %s", id, cp);
! 1008: }
! 1009:
! 1010: /* Set the platform dynamics */
! 1011: static struct {
! 1012: struct jheader jheader;
! 1013: struct jplat jplat;
! 1014: } platmsg = {
! 1015: { putshort(JUPITER_SYNC), putshort(JUPITER_I_PLAT),
! 1016: putshort((sizeof(struct jplat) / sizeof(u_short)) - 1), 0,
! 1017: JUPITER_FLAG_REQUEST | JUPITER_FLAG_NAK, 0 },
! 1018: { 0, 0, 0 }
! 1019: };
! 1020:
! 1021: static void
! 1022: jupiter_platform(struct instance *instance, u_int platform)
! 1023: {
! 1024: struct jheader *hp;
! 1025: struct jplat *pp;
! 1026: char *cp;
! 1027:
! 1028: hp = &platmsg.jheader;
! 1029: pp = &platmsg.jplat;
! 1030: pp->platform = putshort(platform);
! 1031: if ((cp = jupiter_send(instance, hp)) != NULL)
! 1032: jupiter_debug(instance->peer, "jupiter_platform", "%u: %s", platform, cp);
! 1033: }
! 1034:
! 1035: /* Checksum "len" shorts */
! 1036: static u_short
! 1037: jupiter_cksum(u_short *sp, u_int len)
! 1038: {
! 1039: u_short sum, x;
! 1040:
! 1041: sum = 0;
! 1042: while (len-- > 0) {
! 1043: x = *sp++;
! 1044: sum += getshort(x);
! 1045: }
! 1046: return (~sum + 1);
! 1047: }
! 1048:
! 1049: /* Return the size of the next message (or zero if we don't have it all yet) */
! 1050: static int
! 1051: jupiter_recv(struct instance *instance)
! 1052: {
! 1053: int n, len, size, cc;
! 1054: struct jheader *hp;
! 1055: u_char *bp;
! 1056: u_short *sp;
! 1057:
! 1058: /* Must have at least a header's worth */
! 1059: cc = sizeof(*hp);
! 1060: size = instance->ssize;
! 1061: if (size < cc)
! 1062: return (0);
! 1063:
! 1064: /* Search for the sync short if missing */
! 1065: sp = instance->sbuf;
! 1066: hp = (struct jheader *)sp;
! 1067: if (getshort(hp->sync) != JUPITER_SYNC) {
! 1068: /* Wasn't at the front, sync up */
! 1069: jupiter_debug(instance->peer, "jupiter_recv", "syncing");
! 1070: bp = (u_char *)sp;
! 1071: n = size;
! 1072: while (n >= 2) {
! 1073: if (bp[0] != (JUPITER_SYNC & 0xff)) {
! 1074: /*
! 1075: jupiter_debug(instance->peer, "{0x%x}", bp[0]);
! 1076: */
! 1077: ++bp;
! 1078: --n;
! 1079: continue;
! 1080: }
! 1081: if (bp[1] == ((JUPITER_SYNC >> 8) & 0xff))
! 1082: break;
! 1083: /*
! 1084: jupiter_debug(instance->peer, "{0x%x 0x%x}", bp[0], bp[1]);
! 1085: */
! 1086: bp += 2;
! 1087: n -= 2;
! 1088: }
! 1089: /*
! 1090: jupiter_debug(instance->peer, "\n");
! 1091: */
! 1092: /* Shuffle data to front of input buffer */
! 1093: if (n > 0)
! 1094: memcpy(sp, bp, n);
! 1095: size = n;
! 1096: instance->ssize = size;
! 1097: if (size < cc || hp->sync != JUPITER_SYNC)
! 1098: return (0);
! 1099: }
! 1100:
! 1101: if (jupiter_cksum(sp, (cc / sizeof(u_short) - 1)) !=
! 1102: getshort(hp->hsum)) {
! 1103: jupiter_debug(instance->peer, "jupiter_recv", "bad header checksum!");
! 1104: /* This is drastic but checksum errors should be rare */
! 1105: instance->ssize = 0;
! 1106: return (0);
! 1107: }
! 1108:
! 1109: /* Check for a payload */
! 1110: len = getshort(hp->len);
! 1111: if (len > 0) {
! 1112: n = (len + 1) * sizeof(u_short);
! 1113: /* Not enough data yet */
! 1114: if (size < cc + n)
! 1115: return (0);
! 1116:
! 1117: /* Check payload checksum */
! 1118: sp = (u_short *)(hp + 1);
! 1119: if (jupiter_cksum(sp, len) != getshort(sp[len])) {
! 1120: jupiter_debug(instance->peer,
! 1121: "jupiter_recv", "bad payload checksum!");
! 1122: /* This is drastic but checksum errors should be rare */
! 1123: instance->ssize = 0;
! 1124: return (0);
! 1125: }
! 1126: cc += n;
! 1127: }
! 1128: return (cc);
! 1129: }
! 1130:
! 1131: #else /* not (REFCLOCK && CLOCK_JUPITER && HAVE_PPSAPI) */
! 1132: int refclock_jupiter_bs;
! 1133: #endif /* not (REFCLOCK && CLOCK_JUPITER && HAVE_PPSAPI) */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to refclock_jupiter.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / ntpd