refclock_jupiter.c revision 82498
1/* 2 * Copyright (c) 1997, 1998 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(PPS) 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#include "ntp_calendar.h" 46 47#include <stdio.h> 48#include <ctype.h> 49 50#include "jupiter.h" 51 52#include <sys/ppsclock.h> 53 54#ifdef XNTP_BIG_ENDIAN 55#define getshort(s) ((((s) & 0xff) << 8) | (((s) >> 8) & 0xff)) 56#define putshort(s) ((((s) & 0xff) << 8) | (((s) >> 8) & 0xff)) 57#else 58#define getshort(s) (s) 59#define putshort(s) (s) 60#endif 61 62/* XXX */ 63#ifdef sun 64char *strerror(int); 65#endif 66 67/* 68 * This driver supports the Rockwell Jupiter GPS Receiver board 69 * adapted to precision timing applications. It requires the 70 * ppsclock line discipline or streams module described in the 71 * Line Disciplines and Streams Drivers page. It also requires a 72 * gadget box and 1-PPS level converter, such as described in the 73 * Pulse-per-second (PPS) Signal Interfacing page. 74 * 75 * It may work (with minor modifications) with other Rockwell GPS 76 * receivers such as the CityTracker. 77 */ 78 79/* 80 * GPS Definitions 81 */ 82#define DEVICE "/dev/gps%d" /* device name and unit */ 83#define SPEED232 B9600 /* baud */ 84 85/* 86 * The number of raw samples which we acquire to derive a single estimate. 87 * NSAMPLES ideally should not exceed the default poll interval 64. 88 * NKEEP must be a power of 2 to simplify the averaging process. 89 */ 90#define NSAMPLES 64 91#define NKEEP 8 92#define REFCLOCKMAXDISPERSE .25 /* max sample dispersion */ 93 94/* 95 * Radio interface parameters 96 */ 97#define PRECISION (-18) /* precision assumed (about 4 us) */ 98#define REFID "GPS\0" /* reference id */ 99#define DESCRIPTION "Rockwell Jupiter GPS Receiver" /* who we are */ 100#define DEFFUDGETIME 0 /* default fudge time (ms) */ 101 102/* Unix timestamp for the GPS epoch: January 6, 1980 */ 103#define GPS_EPOCH 315964800 104 105/* Double short to unsigned int */ 106#define DS2UI(p) ((getshort((p)[1]) << 16) | getshort((p)[0])) 107 108/* Double short to signed int */ 109#define DS2I(p) ((getshort((p)[1]) << 16) | getshort((p)[0])) 110 111/* One week's worth of seconds */ 112#define WEEKSECS (7 * 24 * 60 * 60) 113 114/* 115 * Jupiter unit control structure. 116 */ 117struct jupiterunit { 118 u_int pollcnt; /* poll message counter */ 119 u_int polled; /* Hand in a time sample? */ 120 u_int lastserial; /* last pps serial number */ 121 struct ppsclockev ppsev; /* PPS control structure */ 122 u_int gweek; /* current GPS week number */ 123 u_int32 lastsweek; /* last seconds into GPS week */ 124 u_int32 timecode; /* current ntp timecode */ 125 u_int32 stime; /* used to detect firmware bug */ 126 int wantid; /* don't reconfig on channel id msg */ 127 u_int moving; /* mobile platform? */ 128 u_long sloppyclockflag; /* fudge flags */ 129 u_int known; /* position known yet? */ 130 int coderecv; /* total received samples */ 131 int nkeep; /* number of samples to preserve */ 132 int rshift; /* number of rshifts for division */ 133 l_fp filter[NSAMPLES]; /* offset filter */ 134 l_fp lastref; /* last reference timestamp */ 135 u_short sbuf[512]; /* local input buffer */ 136 int ssize; /* space used in sbuf */ 137}; 138 139/* 140 * Function prototypes 141 */ 142static void jupiter_canmsg P((struct peer *, u_int)); 143static u_short jupiter_cksum P((u_short *, u_int)); 144#ifdef QSORT_USES_VOID_P 145 int jupiter_cmpl_fp P((const void *, const void *)); 146#else 147 int jupiter_cmpl_fp P((const l_fp *, const l_fp *)); 148#endif /* not QSORT_USES_VOID_P */ 149static void jupiter_config P((struct peer *)); 150static void jupiter_debug P((struct peer *, char *, ...)) 151 __attribute__ ((format (printf, 2, 3))); 152static char * jupiter_offset P((struct peer *)); 153static char * jupiter_parse_t P((struct peer *, u_short *)); 154static void jupiter_platform P((struct peer *, u_int)); 155static void jupiter_poll P((int, struct peer *)); 156static int jupiter_pps P((struct peer *)); 157static char * jupiter_process P((struct peer *)); 158static int jupiter_recv P((struct peer *)); 159static void jupiter_receive P((register struct recvbuf *rbufp)); 160static void jupiter_reqmsg P((struct peer *, u_int, u_int)); 161static void jupiter_reqonemsg P((struct peer *, u_int)); 162static char * jupiter_send P((struct peer *, struct jheader *)); 163static void jupiter_shutdown P((int, struct peer *)); 164static int jupiter_start P((int, struct peer *)); 165static int jupiter_ttyinit P((struct peer *, int)); 166 167/* 168 * Transfer vector 169 */ 170struct refclock refclock_jupiter = { 171 jupiter_start, /* start up driver */ 172 jupiter_shutdown, /* shut down driver */ 173 jupiter_poll, /* transmit poll message */ 174 noentry, /* (clock control) */ 175 noentry, /* (clock init) */ 176 noentry, /* (clock buginfo) */ 177 NOFLAGS /* not used */ 178}; 179 180/* 181 * jupiter_start - open the devices and initialize data for processing 182 */ 183static int 184jupiter_start( 185 register int unit, 186 register struct peer *peer 187 ) 188{ 189 struct refclockproc *pp; 190 register struct jupiterunit *up; 191 register int fd; 192 char gpsdev[20]; 193 194 /* 195 * Open serial port 196 */ 197 (void)sprintf(gpsdev, DEVICE, unit); 198 fd = open(gpsdev, O_RDWR 199#ifdef O_NONBLOCK 200 | O_NONBLOCK 201#endif 202 , 0); 203 if (fd < 0) { 204 jupiter_debug(peer, "jupiter_start: open %s: %s\n", 205 gpsdev, strerror(errno)); 206 return (0); 207 } 208 if (!jupiter_ttyinit(peer, fd)) 209 return (0); 210 211 /* Allocate unit structure */ 212 if ((up = (struct jupiterunit *) 213 emalloc(sizeof(struct jupiterunit))) == NULL) { 214 (void) close(fd); 215 return (0); 216 } 217 memset((char *)up, 0, sizeof(struct jupiterunit)); 218 pp = peer->procptr; 219 pp->io.clock_recv = jupiter_receive; 220 pp->io.srcclock = (caddr_t)peer; 221 pp->io.datalen = 0; 222 pp->io.fd = fd; 223 if (!io_addclock(&pp->io)) { 224 (void) close(fd); 225 free(up); 226 return (0); 227 } 228 pp->unitptr = (caddr_t)up; 229 230 /* 231 * Initialize miscellaneous variables 232 */ 233 peer->precision = PRECISION; 234 pp->clockdesc = DESCRIPTION; 235 memcpy((char *)&pp->refid, REFID, 4); 236 237 238 /* Ensure the receiver is properly configured */ 239 jupiter_config(peer); 240 241 /* Turn on pulse gathering by requesting the first sample */ 242 if (ioctl(fd, CIOGETEV, (caddr_t)&up->ppsev) < 0) { 243 jupiter_debug(peer, "jupiter_ttyinit: CIOGETEV: %s\n", 244 strerror(errno)); 245 (void) close(fd); 246 free(up); 247 return (0); 248 } 249 up->lastserial = up->ppsev.serial; 250 memset(&up->ppsev, 0, sizeof(up->ppsev)); 251 return (1); 252} 253 254/* 255 * jupiter_shutdown - shut down the clock 256 */ 257static void 258jupiter_shutdown(register int unit, register struct peer *peer) 259{ 260 register struct jupiterunit *up; 261 struct refclockproc *pp; 262 263 pp = peer->procptr; 264 up = (struct jupiterunit *)pp->unitptr; 265 io_closeclock(&pp->io); 266 free(up); 267} 268 269/* 270 * jupiter_config - Configure the receiver 271 */ 272static void 273jupiter_config(register struct peer *peer) 274{ 275 register int i; 276 register struct jupiterunit *up; 277 register struct refclockproc *pp; 278 279 pp = peer->procptr; 280 up = (struct jupiterunit *)pp->unitptr; 281 282 /* 283 * Initialize the unit variables 284 * 285 * STRANGE BEHAVIOUR WARNING: The fudge flags are not available 286 * at the time jupiter_start is called. These are set later, 287 * and so the code must be prepared to handle changing flags. 288 */ 289 up->sloppyclockflag = pp->sloppyclockflag; 290 if (pp->sloppyclockflag & CLK_FLAG2) { 291 up->moving = 1; /* Receiver on mobile platform */ 292 msyslog(LOG_DEBUG, "jupiter_config: mobile platform"); 293 } else { 294 up->moving = 0; /* Static Installation */ 295 } 296 297 /* XXX fludge flags don't make the trip from the config to here... */ 298#ifdef notdef 299 /* Configure for trailing edge triggers */ 300#ifdef CIOSETTET 301 i = ((pp->sloppyclockflag & CLK_FLAG3) != 0); 302 jupiter_debug(peer, "jupiter_configure: (sloppyclockflag 0x%lx)\n", 303 pp->sloppyclockflag); 304 if (ioctl(pp->io.fd, CIOSETTET, (char *)&i) < 0) 305 msyslog(LOG_DEBUG, "jupiter_configure: CIOSETTET %d: %m", i); 306#else 307 if (pp->sloppyclockflag & CLK_FLAG3) 308 msyslog(LOG_DEBUG, "jupiter_configure: \ 309No kernel support for trailing edge trigger"); 310#endif 311#endif 312 313 up->pollcnt = 2; 314 up->polled = 0; 315 up->known = 0; 316 up->gweek = 0; 317 up->lastsweek = 2 * WEEKSECS; 318 up->timecode = 0; 319 up->stime = 0; 320 up->ssize = 0; 321 up->coderecv = 0; 322 up->nkeep = NKEEP; 323 if (up->nkeep > NSAMPLES) 324 up->nkeep = NSAMPLES; 325 if (up->nkeep >= 1) 326 up->rshift = 0; 327 if (up->nkeep >= 2) 328 up->rshift = 1; 329 if (up->nkeep >= 4) 330 up->rshift = 2; 331 if (up->nkeep >= 8) 332 up->rshift = 3; 333 if (up->nkeep >= 16) 334 up->rshift = 4; 335 if (up->nkeep >= 32) 336 up->rshift = 5; 337 if (up->nkeep >= 64) 338 up->rshift = 6; 339 up->nkeep = 1; 340 i = up->rshift; 341 while (i > 0) { 342 up->nkeep *= 2; 343 i--; 344 } 345 346 /* Stop outputting all messages */ 347 jupiter_canmsg(peer, JUPITER_ALL); 348 349 /* Request the receiver id so we can syslog the firmware version */ 350 jupiter_reqonemsg(peer, JUPITER_O_ID); 351 352 /* Flag that this the id was requested (so we don't get called again) */ 353 up->wantid = 1; 354 355 /* Request perodic time mark pulse messages */ 356 jupiter_reqmsg(peer, JUPITER_O_PULSE, 1); 357 358 /* Set application platform type */ 359 if (up->moving) 360 jupiter_platform(peer, JUPITER_I_PLAT_MED); 361 else 362 jupiter_platform(peer, JUPITER_I_PLAT_LOW); 363} 364 365/* 366 * jupiter_poll - jupiter watchdog routine 367 */ 368static void 369jupiter_poll(register int unit, register struct peer *peer) 370{ 371 register struct jupiterunit *up; 372 register struct refclockproc *pp; 373 374 pp = peer->procptr; 375 up = (struct jupiterunit *)pp->unitptr; 376 377 /* 378 * You don't need to poll this clock. It puts out timecodes 379 * once per second. If asked for a timestamp, take note. 380 * The next time a timecode comes in, it will be fed back. 381 */ 382 383 /* 384 * If we haven't had a response in a while, reset the receiver. 385 */ 386 if (up->pollcnt > 0) { 387 up->pollcnt--; 388 } else { 389 refclock_report(peer, CEVNT_TIMEOUT); 390 391 /* Request the receiver id to trigger a reconfig */ 392 jupiter_reqonemsg(peer, JUPITER_O_ID); 393 up->wantid = 0; 394 } 395 396 /* 397 * polled every 64 seconds. Ask jupiter_receive to hand in 398 * a timestamp. 399 */ 400 up->polled = 1; 401 pp->polls++; 402} 403 404/* 405 * jupiter_receive - receive gps data 406 * Gag me! 407 */ 408static void 409jupiter_receive(register struct recvbuf *rbufp) 410{ 411 register int bpcnt, cc, size, ppsret; 412 register u_int32 last_timecode, laststime; 413 register char *cp; 414 register u_char *bp; 415 register u_short *sp; 416 register u_long sloppyclockflag; 417 register struct jupiterunit *up; 418 register struct jid *ip; 419 register struct jheader *hp; 420 register struct refclockproc *pp; 421 register struct peer *peer; 422 423 /* Initialize pointers and read the timecode and timestamp */ 424 peer = (struct peer *)rbufp->recv_srcclock; 425 pp = peer->procptr; 426 up = (struct jupiterunit *)pp->unitptr; 427 428 /* 429 * If operating mode has been changed, then reinitialize the receiver 430 * before doing anything else. 431 */ 432/* XXX Sloppy clock flags are broken!! */ 433 sloppyclockflag = up->sloppyclockflag; 434 up->sloppyclockflag = pp->sloppyclockflag; 435 if ((pp->sloppyclockflag & CLK_FLAG2) != 436 (sloppyclockflag & CLK_FLAG2)) { 437 jupiter_debug(peer, 438 "jupiter_receive: mode switch: reset receiver\n"); 439 jupiter_config(peer); 440 return; 441 } 442 443 up->pollcnt = 2; 444 445 bp = (u_char *)rbufp->recv_buffer; 446 bpcnt = rbufp->recv_length; 447 448 /* This shouldn't happen */ 449 if (bpcnt > sizeof(up->sbuf) - up->ssize) 450 bpcnt = sizeof(up->sbuf) - up->ssize; 451 452 /* Append to input buffer */ 453 memcpy((u_char *)up->sbuf + up->ssize, bp, bpcnt); 454 up->ssize += bpcnt; 455 456 /* While there's at least a header and we parse a intact message */ 457 while (up->ssize > sizeof(*hp) && (cc = jupiter_recv(peer)) > 0) { 458 hp = (struct jheader *)up->sbuf; 459 sp = (u_short *)(hp + 1); 460 size = cc - sizeof(*hp); 461 switch (getshort(hp->id)) { 462 463 case JUPITER_O_PULSE: 464 if (size != sizeof(struct jpulse)) { 465 jupiter_debug(peer, 466 "jupiter_receive: pulse: len %d != %u\n", 467 size, (int)sizeof(struct jpulse)); 468 refclock_report(peer, CEVNT_BADREPLY); 469 break; 470 } 471 472 /* 473 * There appears to be a firmware bug related 474 * to the pulse message; in addition to the one 475 * per second messages, we get an extra pulse 476 * message once an hour (on the anniversary of 477 * the cold start). It seems to come 200 ms 478 * after the one requested. So if we've seen a 479 * pulse message in the last 210 ms, we skip 480 * this one. 481 */ 482 laststime = up->stime; 483 up->stime = DS2UI(((struct jpulse *)sp)->stime); 484 if (laststime != 0 && up->stime - laststime <= 21) { 485 jupiter_debug(peer, "jupiter_receive: \ 486avoided firmware bug (stime %.2f, laststime %.2f)\n", 487 (double)up->stime * 0.01, (double)laststime * 0.01); 488 break; 489 } 490 491 /* Retrieve pps timestamp */ 492 ppsret = jupiter_pps(peer); 493 494 /* Parse timecode (even when there's no pps) */ 495 last_timecode = up->timecode; 496 if ((cp = jupiter_parse_t(peer, sp)) != NULL) { 497 jupiter_debug(peer, 498 "jupiter_receive: pulse: %s\n", cp); 499 break; 500 } 501 502 /* Bail if we didn't get a pps timestamp */ 503 if (ppsret) 504 break; 505 506 /* Bail if we don't have the last timecode yet */ 507 if (last_timecode == 0) 508 break; 509 510 /* Add the new sample to a median filter */ 511 if ((cp = jupiter_offset(peer)) != NULL) { 512 jupiter_debug(peer, 513 "jupiter_receive: offset: %s\n", cp); 514 refclock_report(peer, CEVNT_BADTIME); 515 break; 516 } 517 518 /* 519 * The clock will blurt a timecode every second 520 * but we only want one when polled. If we 521 * havn't been polled, bail out. 522 */ 523 if (!up->polled) 524 break; 525 526 /* 527 * It's a live one! Remember this time. 528 */ 529 pp->lasttime = current_time; 530 531 /* 532 * Determine the reference clock offset and 533 * dispersion. NKEEP of NSAMPLE offsets are 534 * passed through a median filter. 535 * Save the (filtered) offset and dispersion in 536 * pp->offset and pp->disp. 537 */ 538 if ((cp = jupiter_process(peer)) != NULL) { 539 jupiter_debug(peer, 540 "jupiter_receive: process: %s\n", cp); 541 refclock_report(peer, CEVNT_BADTIME); 542 break; 543 } 544 /* 545 * Return offset and dispersion to control 546 * module. We use lastrec as both the reference 547 * time and receive time in order to avoid 548 * being cute, like setting the reference time 549 * later than the receive time, which may cause 550 * a paranoid protocol module to chuck out the 551 * data. 552 */ 553 jupiter_debug(peer, 554 "jupiter_receive: process time: \ 555%4d-%03d %02d:%02d:%02d at %s, %s\n", 556 pp->year, pp->day, 557 pp->hour, pp->minute, pp->second, 558 prettydate(&pp->lastrec), lfptoa(&pp->offset, 6)); 559 560 refclock_receive(peer); 561 562 /* 563 * We have succeeded in answering the poll. 564 * Turn off the flag and return 565 */ 566 up->polled = 0; 567 break; 568 569 case JUPITER_O_ID: 570 if (size != sizeof(struct jid)) { 571 jupiter_debug(peer, 572 "jupiter_receive: id: len %d != %u\n", 573 size, (int)sizeof(struct jid)); 574 refclock_report(peer, CEVNT_BADREPLY); 575 break; 576 } 577 /* 578 * If we got this message because the Jupiter 579 * just powered up, it needs to be reconfigured. 580 */ 581 ip = (struct jid *)sp; 582 jupiter_debug(peer, 583 "jupiter_receive: >> %s chan ver %s, %s (%s)\n", 584 ip->chans, ip->vers, ip->date, ip->opts); 585 msyslog(LOG_DEBUG, 586 "jupiter_receive: %s chan ver %s, %s (%s)\n", 587 ip->chans, ip->vers, ip->date, ip->opts); 588 if (up->wantid) 589 up->wantid = 0; 590 else { 591 jupiter_debug(peer, 592 "jupiter_receive: reset receiver\n"); 593 jupiter_config(peer); 594 /* Rese since jupiter_config() just zeroed it */ 595 up->ssize = cc; 596 } 597 break; 598 599 default: 600 jupiter_debug(peer, 601 "jupiter_receive: >> unknown message id %d\n", 602 getshort(hp->id)); 603 break; 604 } 605 up->ssize -= cc; 606 if (up->ssize < 0) { 607 fprintf(stderr, "jupiter_recv: negative ssize!\n"); 608 abort(); 609 } else if (up->ssize > 0) 610 memcpy(up->sbuf, (u_char *)up->sbuf + cc, up->ssize); 611 } 612 record_clock_stats(&peer->srcadr, "<timecode is binary>"); 613} 614 615/* 616 * jupiter_offset - Calculate the offset, and add to the rolling filter. 617 */ 618static char * 619jupiter_offset(register struct peer *peer) 620{ 621 register struct jupiterunit *up; 622 register struct refclockproc *pp; 623 register int i; 624 l_fp offset; 625 626 pp = peer->procptr; 627 up = (struct jupiterunit *)pp->unitptr; 628 629 /* 630 * Calculate the offset 631 */ 632 if (!clocktime(pp->day, pp->hour, pp->minute, pp->second, GMT, 633 pp->lastrec.l_ui, &pp->yearstart, &offset.l_ui)) { 634 return ("jupiter_process: clocktime failed"); 635 } 636 if (pp->usec) { 637 TVUTOTSF(pp->usec, offset.l_uf); 638 } else { 639 MSUTOTSF(pp->msec, offset.l_uf); 640 } 641 L_ADD(&offset, &pp->fudgetime1); 642 up->lastref = offset; /* save last reference time */ 643 L_SUB(&offset, &pp->lastrec); /* form true offset */ 644 645 /* 646 * A rolling filter. Initialize first time around. 647 */ 648 i = ((up->coderecv)) % NSAMPLES; 649 650 up->filter[i] = offset; 651 if (up->coderecv == 0) 652 for (i = 1; (u_int) i < NSAMPLES; i++) 653 up->filter[i] = up->filter[0]; 654 up->coderecv++; 655 656 return (NULL); 657} 658 659/* 660 * jupiter_process - process the sample from the clock, 661 * passing it through a median filter and optionally averaging 662 * the samples. Returns offset and dispersion in "up" structure. 663 */ 664static char * 665jupiter_process(register struct peer *peer) 666{ 667 register struct jupiterunit *up; 668 register struct refclockproc *pp; 669 register int i, n; 670 register int j, k; 671 l_fp offset, median, lftmp; 672 u_fp disp; 673 l_fp off[NSAMPLES]; 674 675 pp = peer->procptr; 676 up = (struct jupiterunit *)pp->unitptr; 677 678 /* 679 * Copy the raw offsets and sort into ascending order 680 */ 681 for (i = 0; i < NSAMPLES; i++) 682 off[i] = up->filter[i]; 683 qsort((char *)off, (size_t)NSAMPLES, sizeof(l_fp), jupiter_cmpl_fp); 684 685 /* 686 * Reject the furthest from the median of NSAMPLES samples until 687 * NKEEP samples remain. 688 */ 689 i = 0; 690 n = NSAMPLES; 691 while ((n - i) > up->nkeep) { 692 lftmp = off[n - 1]; 693 median = off[(n + i) / 2]; 694 L_SUB(&lftmp, &median); 695 L_SUB(&median, &off[i]); 696 if (L_ISHIS(&median, &lftmp)) { 697 /* reject low end */ 698 i++; 699 } else { 700 /* reject high end */ 701 n--; 702 } 703 } 704 705 /* 706 * Copy key values to the billboard to measure performance. 707 */ 708 pp->lastref = up->lastref; 709 pp->coderecv = up->coderecv; 710 pp->filter[0] = off[0]; /* smallest offset */ 711 pp->filter[1] = off[NSAMPLES-1]; /* largest offset */ 712 for (j = 2, k = i; k < n; j++, k++) 713 pp->filter[j] = off[k]; /* offsets actually examined */ 714 715 /* 716 * Compute the dispersion based on the difference between the 717 * extremes of the remaining offsets. Add to this the time since 718 * the last clock update, which represents the dispersion 719 * increase with time. We know that NTP_MAXSKEW is 16. If the 720 * sum is greater than the allowed sample dispersion, bail out. 721 * If the loop is unlocked, return the most recent offset; 722 * otherwise, return the median offset. 723 */ 724 lftmp = off[n - 1]; 725 L_SUB(&lftmp, &off[i]); 726 disp = LFPTOFP(&lftmp); 727 if (disp > REFCLOCKMAXDISPERSE) 728 return ("Maximum dispersion exceeded"); 729 730 /* 731 * Now compute the offset estimate. If fudge flag 1 732 * is set, average the remainder, otherwise pick the 733 * median. 734 */ 735 if (pp->sloppyclockflag & CLK_FLAG1) { 736 L_CLR(&lftmp); 737 while (i < n) { 738 L_ADD(&lftmp, &off[i]); 739 i++; 740 } 741 i = up->rshift; 742 while (i > 0) { 743 L_RSHIFT(&lftmp); 744 i--; 745 } 746 offset = lftmp; 747 } else { 748 i = (n + i) / 2; 749 offset = off[i]; 750 } 751 752 /* 753 * The payload: filtered offset and dispersion. 754 */ 755 756 pp->offset = offset; 757 pp->disp = disp; 758 759 return (NULL); 760 761} 762 763/* Compare two l_fp's, used with qsort() */ 764#ifdef QSORT_USES_VOID_P 765int 766jupiter_cmpl_fp(register const void *p1, register const void *p2) 767#else 768int 769jupiter_cmpl_fp(register const l_fp *fp1, register const l_fp *fp2) 770#endif 771{ 772#ifdef QSORT_USES_VOID_P 773 register const l_fp *fp1 = (const l_fp *)p1; 774 register const l_fp *fp2 = (const l_fp *)p2; 775#endif 776 777 if (!L_ISGEQ(fp1, fp2)) 778 return (-1); 779 if (L_ISEQU(fp1, fp2)) 780 return (0); 781 return (1); 782} 783 784static char * 785jupiter_parse_t(register struct peer *peer, register u_short *sp) 786{ 787 register struct refclockproc *pp; 788 register struct jupiterunit *up; 789 register struct tm *tm; 790 register char *cp; 791 register struct jpulse *jp; 792 register struct calendar *jt; 793 register u_int32 sweek; 794 register u_int32 last_timecode; 795 register u_short flags; 796 time_t t; 797 struct calendar cal; 798 799 pp = peer->procptr; 800 up = (struct jupiterunit *)pp->unitptr; 801 jp = (struct jpulse *)sp; 802 803 /* The timecode is presented as seconds into the current GPS week */ 804 sweek = DS2UI(jp->sweek); 805 806 /* 807 * If we don't know the current GPS week, calculate it from the 808 * current time. (It's too bad they didn't include this 809 * important value in the pulse message). We'd like to pick it 810 * up from one of the other messages like gpos or chan but they 811 * don't appear to be synchronous with time keeping and changes 812 * too soon (something like 10 seconds before the new GPS 813 * week). 814 * 815 * If we already know the current GPS week, increment it when 816 * we wrap into a new week. 817 */ 818 if (up->gweek == 0) 819 up->gweek = (time(NULL) - GPS_EPOCH) / WEEKSECS; 820 else if (sweek == 0 && up->lastsweek == WEEKSECS - 1) { 821 ++up->gweek; 822 jupiter_debug(peer, 823 "jupiter_parse_t: NEW gps week %u\n", up->gweek); 824 } 825 826 /* 827 * See if the sweek stayed the same (this happens when there is 828 * no pps pulse). 829 * 830 * Otherwise, look for time warps: 831 * 832 * - we have stored at least one lastsweek and 833 * - the sweek didn't increase by one and 834 * - we didn't wrap to a new GPS week 835 * 836 * Then we warped. 837 */ 838 if (up->lastsweek == sweek) 839 jupiter_debug(peer, 840 "jupiter_parse_t: gps sweek not incrementing (%d)\n", 841 sweek); 842 else if (up->lastsweek != 2 * WEEKSECS && 843 up->lastsweek + 1 != sweek && 844 !(sweek == 0 && up->lastsweek == WEEKSECS - 1)) 845 jupiter_debug(peer, 846 "jupiter_parse_t: gps sweek jumped (was %d, now %d)\n", 847 up->lastsweek, sweek); 848 up->lastsweek = sweek; 849 850 /* This timecode describes next pulse */ 851 last_timecode = up->timecode; 852 up->timecode = (u_int32)JAN_1970 + 853 GPS_EPOCH + (up->gweek * WEEKSECS) + sweek; 854 855 if (last_timecode == 0) 856 /* XXX debugging */ 857 jupiter_debug(peer, 858 "jupiter_parse_t: UTC <none> (gweek/sweek %u/%u)\n", 859 up->gweek, sweek); 860 else { 861 /* XXX debugging */ 862 t = last_timecode - (u_int32)JAN_1970; 863 tm = gmtime(&t); 864 cp = asctime(tm); 865 866 jupiter_debug(peer, 867 "jupiter_parse_t: UTC %.24s (gweek/sweek %u/%u)\n", 868 cp, up->gweek, sweek); 869 870 /* Billboard last_timecode (which is now the current time) */ 871 jt = &cal; 872 caljulian(last_timecode, jt); 873 pp = peer->procptr; 874 pp->year = jt->year; 875 pp->day = jt->yearday; 876 pp->hour = jt->hour; 877 pp->minute = jt->minute; 878 pp->second = jt->second; 879 pp->msec = 0; 880 pp->usec = 0; 881 } 882 883 /* XXX debugging */ 884 tm = gmtime(&up->ppsev.tv.tv_sec); 885 cp = asctime(tm); 886 flags = getshort(jp->flags); 887 jupiter_debug(peer, 888 "jupiter_parse_t: PPS %.19s.%06lu %.4s (serial %u)%s\n", 889 cp, up->ppsev.tv.tv_usec, cp + 20, up->ppsev.serial, 890 (flags & JUPITER_O_PULSE_VALID) == 0 ? 891 " NOT VALID" : ""); 892 893 /* Toss if not designated "valid" by the gps */ 894 if ((flags & JUPITER_O_PULSE_VALID) == 0) { 895 refclock_report(peer, CEVNT_BADTIME); 896 return ("time mark not valid"); 897 } 898 899 /* We better be sync'ed to UTC... */ 900 if ((flags & JUPITER_O_PULSE_UTC) == 0) { 901 refclock_report(peer, CEVNT_BADTIME); 902 return ("time mark not sync'ed to UTC"); 903 } 904 905 return (NULL); 906} 907 908/* 909 * Process a PPS signal, returning a timestamp. 910 */ 911static int 912jupiter_pps(register struct peer *peer) 913{ 914 register struct refclockproc *pp; 915 register struct jupiterunit *up; 916 register int firsttime; 917 struct timeval ntp_tv; 918 919 pp = peer->procptr; 920 up = (struct jupiterunit *)pp->unitptr; 921 922 /* 923 * Grab the timestamp of the PPS signal. 924 */ 925 firsttime = (up->ppsev.tv.tv_sec == 0); 926 if (ioctl(pp->io.fd, CIOGETEV, (caddr_t)&up->ppsev) < 0) { 927 /* XXX Actually, if this fails, we're pretty much screwed */ 928 jupiter_debug(peer, "jupiter_pps: CIOGETEV: %s\n", 929 strerror(errno)); 930 refclock_report(peer, CEVNT_FAULT); 931 return (1); 932 } 933 934 /* 935 * Check pps serial number against last one 936 */ 937 if (!firsttime && up->lastserial + 1 != up->ppsev.serial) { 938 if (up->ppsev.serial == up->lastserial) 939 jupiter_debug(peer, "jupiter_pps: no new pps event\n"); 940 else 941 jupiter_debug(peer, 942 "jupiter_pps: missed %d pps events\n", 943 up->ppsev.serial - up->lastserial - 1); 944 up->lastserial = up->ppsev.serial; 945 refclock_report(peer, CEVNT_FAULT); 946 return (1); 947 } 948 up->lastserial = up->ppsev.serial; 949 950 /* 951 * Return the timestamp in pp->lastrec 952 */ 953 ntp_tv = up->ppsev.tv; 954 ntp_tv.tv_sec += (u_int32)JAN_1970; 955 TVTOTS(&ntp_tv, &pp->lastrec); 956 957 return (0); 958} 959 960/* 961 * jupiter_debug - print debug messages 962 */ 963#if defined(__STDC__) 964static void 965jupiter_debug(struct peer *peer, char *fmt, ...) 966#else 967static void 968jupiter_debug(peer, fmt, va_alist) 969 struct peer *peer; 970 char *fmt; 971#endif /* __STDC__ */ 972{ 973 va_list ap; 974 975 if (debug) { 976 977#if defined(__STDC__) 978 va_start(ap, fmt); 979#else 980 va_start(ap); 981#endif /* __STDC__ */ 982 /* 983 * Print debug message to stdout 984 * In the future, we may want to get get more creative... 985 */ 986 vfprintf(stderr, fmt, ap); 987 988 va_end(ap); 989 } 990} 991 992/* Checksum and transmit a message to the Jupiter */ 993static char * 994jupiter_send(register struct peer *peer, register struct jheader *hp) 995{ 996 register u_int len, size; 997 register int cc; 998 register u_short *sp; 999 static char errstr[132]; 1000 1001 size = sizeof(*hp); 1002 hp->hsum = putshort(jupiter_cksum((u_short *)hp, 1003 (size / sizeof(u_short)) - 1)); 1004 len = getshort(hp->len); 1005 if (len > 0) { 1006 sp = (u_short *)(hp + 1); 1007 sp[len] = putshort(jupiter_cksum(sp, len)); 1008 size += (len + 1) * sizeof(u_short); 1009 } 1010 1011 if ((cc = write(peer->procptr->io.fd, (char *)hp, size)) < 0) { 1012 (void)sprintf(errstr, "write: %s", strerror(errno)); 1013 return (errstr); 1014 } else if (cc != size) { 1015 (void)sprintf(errstr, "short write (%d != %d)", cc, size); 1016 return (errstr); 1017 } 1018 return (NULL); 1019} 1020 1021/* Request periodic message output */ 1022static struct { 1023 struct jheader jheader; 1024 struct jrequest jrequest; 1025} reqmsg = { 1026 { putshort(JUPITER_SYNC), 0, 1027 putshort((sizeof(struct jrequest) / sizeof(u_short)) - 1), 1028 0, putshort(JUPITER_FLAG_REQUEST | JUPITER_FLAG_NAK | 1029 JUPITER_FLAG_CONN | JUPITER_FLAG_LOG), 0 }, 1030 { 0, 0, 0, 0 } 1031}; 1032 1033/* An interval of zero means to output on trigger */ 1034static void 1035jupiter_reqmsg(register struct peer *peer, register u_int id, 1036 register u_int interval) 1037{ 1038 register struct jheader *hp; 1039 register struct jrequest *rp; 1040 register char *cp; 1041 1042 hp = &reqmsg.jheader; 1043 hp->id = putshort(id); 1044 rp = &reqmsg.jrequest; 1045 rp->trigger = putshort(interval == 0); 1046 rp->interval = putshort(interval); 1047 if ((cp = jupiter_send(peer, hp)) != NULL) 1048 jupiter_debug(peer, "jupiter_reqmsg: %u: %s\n", id, cp); 1049} 1050 1051/* Cancel periodic message output */ 1052static struct jheader canmsg = { 1053 putshort(JUPITER_SYNC), 0, 0, 0, 1054 putshort(JUPITER_FLAG_REQUEST | JUPITER_FLAG_NAK | JUPITER_FLAG_DISC), 1055 0 1056}; 1057 1058static void 1059jupiter_canmsg(register struct peer *peer, register u_int id) 1060{ 1061 register struct jheader *hp; 1062 register char *cp; 1063 1064 hp = &canmsg; 1065 hp->id = putshort(id); 1066 if ((cp = jupiter_send(peer, hp)) != NULL) 1067 jupiter_debug(peer, "jupiter_canmsg: %u: %s\n", id, cp); 1068} 1069 1070/* Request a single message output */ 1071static struct jheader reqonemsg = { 1072 putshort(JUPITER_SYNC), 0, 0, 0, 1073 putshort(JUPITER_FLAG_REQUEST | JUPITER_FLAG_NAK | JUPITER_FLAG_QUERY), 1074 0 1075}; 1076 1077static void 1078jupiter_reqonemsg(register struct peer *peer, register u_int id) 1079{ 1080 register struct jheader *hp; 1081 register char *cp; 1082 1083 hp = &reqonemsg; 1084 hp->id = putshort(id); 1085 if ((cp = jupiter_send(peer, hp)) != NULL) 1086 jupiter_debug(peer, "jupiter_reqonemsg: %u: %s\n", id, cp); 1087} 1088 1089/* Set the platform dynamics */ 1090static struct { 1091 struct jheader jheader; 1092 struct jplat jplat; 1093} platmsg = { 1094 { putshort(JUPITER_SYNC), putshort(JUPITER_I_PLAT), 1095 putshort((sizeof(struct jplat) / sizeof(u_short)) - 1), 0, 1096 putshort(JUPITER_FLAG_REQUEST | JUPITER_FLAG_NAK), 0 }, 1097 { 0, 0, 0 } 1098}; 1099 1100static void 1101jupiter_platform(register struct peer *peer, register u_int platform) 1102{ 1103 register struct jheader *hp; 1104 register struct jplat *pp; 1105 register char *cp; 1106 1107 hp = &platmsg.jheader; 1108 pp = &platmsg.jplat; 1109 pp->platform = putshort(platform); 1110 if ((cp = jupiter_send(peer, hp)) != NULL) 1111 jupiter_debug(peer, "jupiter_platform: %u: %s\n", platform, cp); 1112} 1113 1114/* Checksum "len" shorts */ 1115static u_short 1116jupiter_cksum(register u_short *sp, register u_int len) 1117{ 1118 register u_short sum, x; 1119 1120 sum = 0; 1121 while (len-- > 0) { 1122 x = *sp++; 1123 sum += getshort(x); 1124 } 1125 return (~sum + 1); 1126} 1127 1128/* Return the size of the next message (or zero if we don't have it all yet) */ 1129static int 1130jupiter_recv(register struct peer *peer) 1131{ 1132 register int n, len, size, cc; 1133 register struct refclockproc *pp; 1134 register struct jupiterunit *up; 1135 register struct jheader *hp; 1136 register u_char *bp; 1137 register u_short *sp; 1138 1139 pp = peer->procptr; 1140 up = (struct jupiterunit *)pp->unitptr; 1141 1142 /* Must have at least a header's worth */ 1143 cc = sizeof(*hp); 1144 size = up->ssize; 1145 if (size < cc) 1146 return (0); 1147 1148 /* Search for the sync short if missing */ 1149 sp = up->sbuf; 1150 hp = (struct jheader *)sp; 1151 if (getshort(hp->sync) != JUPITER_SYNC) { 1152 /* Wasn't at the front, sync up */ 1153 jupiter_debug(peer, "syncing"); 1154 bp = (u_char *)sp; 1155 n = size; 1156 while (n >= 2) { 1157 if (bp[0] != (JUPITER_SYNC & 0xff)) { 1158 jupiter_debug(peer, "{0x%x}", bp[0]); 1159 ++bp; 1160 --n; 1161 continue; 1162 } 1163 if (bp[1] == ((JUPITER_SYNC >> 8) & 0xff)) 1164 break; 1165 jupiter_debug(peer, "{0x%x 0x%x}", bp[0], bp[1]); 1166 bp += 2; 1167 n -= 2; 1168 } 1169 jupiter_debug(peer, "\n"); 1170 /* Shuffle data to front of input buffer */ 1171 if (n > 0) 1172 memcpy(sp, bp, n); 1173 size = n; 1174 up->ssize = size; 1175 if (size < cc || hp->sync != JUPITER_SYNC) 1176 return (0); 1177 } 1178 1179 if (jupiter_cksum(sp, (cc / sizeof(u_short) - 1)) != 1180 getshort(hp->hsum)) { 1181 jupiter_debug(peer, "jupiter_recv: bad header checksum!\n"); 1182 /* This is drastic but checksum errors should be rare */ 1183 up->ssize = 0; 1184 return (0); 1185 } 1186 1187 /* Check for a payload */ 1188 len = getshort(hp->len); 1189 if (len > 0) { 1190 n = (len + 1) * sizeof(u_short); 1191 /* Not enough data yet */ 1192 if (size < cc + n) 1193 return (0); 1194 1195 /* Check payload checksum */ 1196 sp = (u_short *)(hp + 1); 1197 if (jupiter_cksum(sp, len) != getshort(sp[len])) { 1198 jupiter_debug(peer, 1199 "jupiter_recv: bad payload checksum!\n"); 1200 /* This is drastic but checksum errors should be rare */ 1201 up->ssize = 0; 1202 return (0); 1203 } 1204 cc += n; 1205 } 1206 return (cc); 1207} 1208 1209static int 1210jupiter_ttyinit(register struct peer *peer, register int fd) 1211{ 1212 struct termios termios; 1213 1214 memset((char *)&termios, 0, sizeof(termios)); 1215 if (cfsetispeed(&termios, B9600) < 0 || 1216 cfsetospeed(&termios, B9600) < 0) { 1217 jupiter_debug(peer, 1218 "jupiter_ttyinit: cfsetispeed/cfgetospeed: %s\n", 1219 strerror(errno)); 1220 return (0); 1221 } 1222#ifdef HAVE_CFMAKERAW 1223 cfmakeraw(&termios); 1224#else 1225 termios.c_iflag &= ~(IMAXBEL | IXOFF | INPCK | BRKINT | PARMRK | 1226 ISTRIP | INLCR | IGNCR | ICRNL | IXON | IGNPAR); 1227 termios.c_iflag |= IGNBRK; 1228 termios.c_oflag &= ~OPOST; 1229 termios.c_lflag &= ~(ECHO | ECHOE | ECHOK | ECHONL | ICANON | ISIG | 1230 IEXTEN | NOFLSH | TOSTOP | PENDIN); 1231 termios.c_cflag &= ~(CSIZE | PARENB); 1232 termios.c_cflag |= CS8 | CREAD; 1233 termios.c_cc[VMIN] = 1; 1234#endif 1235 termios.c_cflag |= CLOCAL; 1236 if (tcsetattr(fd, TCSANOW, &termios) < 0) { 1237 jupiter_debug(peer, "jupiter_ttyinit: tcsetattr: %s\n", 1238 strerror(errno)); 1239 return (0); 1240 } 1241 1242#ifdef TIOCSPPS 1243 if (ioctl(fd, TIOCSPPS, (char *)&fdpps) < 0) { 1244 jupiter_debug(peer, "jupiter_ttyinit: TIOCSPPS: %s\n", 1245 strerror(errno)); 1246 return (0); 1247 } 1248#endif 1249#ifdef I_PUSH 1250 if (ioctl(fd, I_PUSH, "ppsclock") < 0) { 1251 jupiter_debug(peer, "jupiter_ttyinit: push ppsclock: %s\n", 1252 strerror(errno)); 1253 return (0); 1254 } 1255#endif 1256 1257 return (1); 1258} 1259 1260#else /* not (REFCLOCK && CLOCK_JUPITER && PPS) */ 1261int refclock_jupiter_bs; 1262#endif /* not (REFCLOCK && CLOCK_JUPITER && PPS) */ 1263