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 /* This clock *REQUIRES* the PPS API to be available */ 39 #if defined(REFCLOCK) && defined(CLOCK_JUPITER) && defined(HAVE_PPSAPI) 40 41 #include "ntpd.h" 42 #include "ntp_io.h" 43 #include "ntp_refclock.h" 44 #include "ntp_unixtime.h" 45 #include "ntp_stdlib.h" 46 #include "ntp_calendar.h" 47 #include "ntp_calgps.h" 48 #include "timespecops.h" 49 50 #include <stdio.h> 51 #include <ctype.h> 52 53 #include "jupiter.h" 54 #include "ppsapi_timepps.h" 55 56 #ifdef WORDS_BIGENDIAN 57 #define getshort(s) ((((s) & 0xff) << 8) | (((s) >> 8) & 0xff)) 58 #define putshort(s) ((((s) & 0xff) << 8) | (((s) >> 8) & 0xff)) 59 #else 60 #define getshort(s) ((u_short)(s)) 61 #define putshort(s) ((u_short)(s)) 62 #endif 63 64 /* 65 * This driver supports the Rockwell Jupiter GPS Receiver board 66 * adapted to precision timing applications. It requires the 67 * ppsclock line discipline or streams module described in the 68 * Line Disciplines and Streams Drivers page. It also requires a 69 * gadget box and 1-PPS level converter, such as described in the 70 * Pulse-per-second (PPS) Signal Interfacing page. 71 * 72 * It may work (with minor modifications) with other Rockwell GPS 73 * receivers such as the CityTracker. 74 */ 75 76 /* 77 * GPS Definitions 78 */ 79 #define DEVICE "/dev/gps%d" /* device name and unit */ 80 #define SPEED232 B9600 /* baud */ 81 82 /* 83 * Radio interface parameters 84 */ 85 #define PRECISION (-18) /* precision assumed (about 4 us) */ 86 #define REFID "GPS\0" /* reference id */ 87 #define DESCRIPTION "Rockwell Jupiter GPS Receiver" /* who we are */ 88 #define DEFFUDGETIME 0 /* default fudge time (ms) */ 89 90 /* Unix timestamp for the GPS epoch: January 6, 1980 */ 91 #define GPS_EPOCH 315964800 92 93 /* Rata Die Number of first day of GPS epoch. This is the number of days 94 * since 0000-12-31 to 1980-01-06 in the proleptic Gregorian Calendar. 95 */ 96 #define RDN_GPS_EPOCH (4*146097 + 138431 + 1) 97 98 /* Double short to unsigned int */ 99 #define DS2UI(p) ((getshort((p)[1]) << 16) | getshort((p)[0])) 100 101 /* Double short to signed int */ 102 #define DS2I(p) ((getshort((p)[1]) << 16) | getshort((p)[0])) 103 104 /* One week's worth of seconds */ 105 #define WEEKSECS (7 * 24 * 60 * 60) 106 107 /* 108 * Jupiter unit control structure. 109 */ 110 struct instance { 111 struct peer *peer; /* peer */ 112 113 pps_params_t pps_params; /* pps parameters */ 114 pps_info_t pps_info; /* last pps data */ 115 pps_handle_t pps_handle; /* pps handle */ 116 u_int assert; /* pps edge to use */ 117 u_int hardpps; /* enable kernel mode */ 118 l_fp rcv_pps; /* last pps timestamp */ 119 l_fp rcv_next; /* rcv time of next reftime */ 120 TGpsDatum ref_next; /* next GPS time stamp to use with PPS */ 121 TGpsDatum piv_next; /* pivot for week date unfolding */ 122 uint16_t piv_hold; /* TTL for pivot value */ 123 uint16_t rcvtout; /* receive timeout ticker */ 124 int wantid; /* don't reconfig on channel id msg */ 125 u_int moving; /* mobile platform? */ 126 u_char sloppyclockflag; /* fudge flags */ 127 u_short sbuf[512]; /* local input buffer */ 128 int ssize; /* space used in sbuf */ 129 }; 130 131 /* 132 * Function prototypes 133 */ 134 static void jupiter_canmsg (struct instance * const, u_int); 135 static u_short jupiter_cksum (u_short *, u_int); 136 static int jupiter_config (struct instance * const); 137 static void jupiter_debug (struct peer *, const char *, 138 const char *, ...) NTP_PRINTF(3, 4); 139 static const char * jupiter_parse_t (struct instance * const, u_short *, l_fp); 140 static const char * jupiter_parse_gpos(struct instance * const, u_short *); 141 static void jupiter_platform(struct instance * const, u_int); 142 static void jupiter_poll (int, struct peer *); 143 static void jupiter_control (int, const struct refclockstat *, 144 struct refclockstat *, struct peer *); 145 static int jupiter_ppsapi (struct instance * const); 146 static int jupiter_pps (struct instance * const); 147 static int jupiter_recv (struct instance * const); 148 static void jupiter_receive (struct recvbuf * const rbufp); 149 static void jupiter_reqmsg (struct instance * const, u_int, u_int); 150 static void jupiter_reqonemsg(struct instance * const, u_int); 151 static char * jupiter_send (struct instance * const, struct jheader *); 152 static void jupiter_shutdown(int, struct peer *); 153 static int jupiter_start (int, struct peer *); 154 static void jupiter_ticker (int, struct peer *); 155 156 /* 157 * Transfer vector 158 */ 159 struct refclock refclock_jupiter = { 160 jupiter_start, /* start up driver */ 161 jupiter_shutdown, /* shut down driver */ 162 jupiter_poll, /* transmit poll message */ 163 jupiter_control, /* (clock control) */ 164 noentry, /* (clock init) */ 165 noentry, /* (clock buginfo) */ 166 jupiter_ticker /* 1HZ ticker */ 167 }; 168 169 /* 170 * jupiter_start - open the devices and initialize data for processing 171 */ 172 static int 173 jupiter_start( 174 int unit, 175 struct peer *peer 176 ) 177 { 178 struct refclockproc * const pp = peer->procptr; 179 struct instance * up; 180 int fd; 181 char gpsdev[20]; 182 183 /* 184 * Open serial port 185 */ 186 snprintf(gpsdev, sizeof(gpsdev), DEVICE, unit); 187 fd = refclock_open(&peer->srcadr, gpsdev, SPEED232, LDISC_RAW); 188 if (fd <= 0) { 189 jupiter_debug(peer, "jupiter_start", "open %s: %m", 190 gpsdev); 191 return (0); 192 } 193 194 /* Allocate unit structure */ 195 up = emalloc_zero(sizeof(*up)); 196 up->peer = peer; 197 pp->io.clock_recv = jupiter_receive; 198 pp->io.srcclock = peer; 199 pp->io.datalen = 0; 200 pp->io.fd = fd; 201 if (!io_addclock(&pp->io)) { 202 close(fd); 203 pp->io.fd = -1; 204 free(up); 205 return (0); 206 } 207 pp->unitptr = up; 208 209 /* 210 * Initialize miscellaneous variables 211 */ 212 peer->precision = PRECISION; 213 pp->clockdesc = DESCRIPTION; 214 memcpy((char *)&pp->refid, REFID, 4); 215 216 up->assert = 1; 217 up->hardpps = 0; 218 /* 219 * Start the PPSAPI interface if it is there. Default to use 220 * the assert edge and do not enable the kernel hardpps. 221 */ 222 if (time_pps_create(fd, &up->pps_handle) < 0) { 223 up->pps_handle = 0; 224 msyslog(LOG_ERR, 225 "refclock_jupiter: time_pps_create failed: %m"); 226 } 227 else if (!jupiter_ppsapi(up)) 228 goto clean_up; 229 230 /* Ensure the receiver is properly configured */ 231 if (!jupiter_config(up)) 232 goto clean_up; 233 234 jupiter_pps(up); /* get current PPS state */ 235 return (1); 236 237 clean_up: 238 jupiter_shutdown(unit, peer); 239 pp->unitptr = 0; 240 return (0); 241 } 242 243 /* 244 * jupiter_shutdown - shut down the clock 245 */ 246 static void 247 jupiter_shutdown(int unit, struct peer *peer) 248 { 249 struct refclockproc * const pp = peer->procptr; 250 struct instance * const up = pp->unitptr; 251 252 if (!up) 253 return; 254 255 if (up->pps_handle) { 256 time_pps_destroy(up->pps_handle); 257 up->pps_handle = 0; 258 } 259 260 if (pp->io.fd != -1) 261 io_closeclock(&pp->io); 262 free(up); 263 } 264 265 /* 266 * jupiter_config - Configure the receiver 267 */ 268 static int 269 jupiter_config(struct instance * const up) 270 { 271 jupiter_debug(up->peer, __func__, "init receiver"); 272 273 /* 274 * Initialize the unit variables 275 */ 276 up->sloppyclockflag = up->peer->procptr->sloppyclockflag; 277 up->moving = !!(up->sloppyclockflag & CLK_FLAG2); 278 if (up->moving) 279 jupiter_debug(up->peer, __func__, "mobile platform"); 280 281 ZERO(up->rcv_next); 282 ZERO(up->ref_next); 283 ZERO(up->piv_next); 284 up->ssize = 0; 285 286 /* Stop outputting all messages */ 287 jupiter_canmsg(up, JUPITER_ALL); 288 289 /* Request the receiver id so we can syslog the firmware version */ 290 jupiter_reqonemsg(up, JUPITER_O_ID); 291 292 /* Flag that this the id was requested (so we don't get called again) */ 293 up->wantid = 1; 294 295 /* Request perodic time mark pulse messages */ 296 jupiter_reqmsg(up, JUPITER_O_PULSE, 1); 297 298 /* Request perodic geodetic position status */ 299 jupiter_reqmsg(up, JUPITER_O_GPOS, 1); 300 301 /* Set application platform type */ 302 if (up->moving) 303 jupiter_platform(up, JUPITER_I_PLAT_MED); 304 else 305 jupiter_platform(up, JUPITER_I_PLAT_LOW); 306 307 return (1); 308 } 309 310 static void 311 jupiter_checkpps( 312 struct refclockproc * const pp, 313 struct instance * const up 314 ) 315 { 316 l_fp tstamp, delta; 317 struct calendar cd; 318 319 if (jupiter_pps(up) || !up->piv_next.weeks) 320 return; 321 322 /* check delay between pulse message and pulse. */ 323 delta = up->rcv_pps; /* set by jupiter_pps() */ 324 L_SUB(&delta, &up->rcv_next); /* recv time pulse message */ 325 if (delta.l_ui != 0 || delta.l_uf >= 0xC0000000) { 326 up->ref_next.weeks = 0; /* consider as consumed... */ 327 return; 328 } 329 330 pp->lastrec = up->rcv_pps; 331 tstamp = ntpfp_from_gpsdatum(&up->ref_next); 332 refclock_process_offset(pp, tstamp, up->rcv_pps, pp->fudgetime1); 333 up->rcvtout = 2; 334 335 gpscal_to_calendar(&cd, &up->ref_next); 336 refclock_save_lcode(pp, ntpcal_iso8601std(NULL, 0, &cd), 337 (size_t)-1); 338 up->ref_next.weeks = 0; /* consumed... */ 339 } 340 341 /* 342 * jupiter_ticker - process periodic checks 343 */ 344 static void 345 jupiter_ticker(int unit, struct peer *peer) 346 { 347 struct refclockproc * const pp = peer->procptr; 348 struct instance * const up = pp->unitptr; 349 350 if (!up) 351 return; 352 353 /* check if we can add another sample now */ 354 jupiter_checkpps(pp, up); 355 356 /* check the pivot update cycle */ 357 if (up->piv_hold && !--up->piv_hold) 358 ZERO(up->piv_next); 359 360 if (up->rcvtout) 361 --up->rcvtout; 362 else if (pp->coderecv != pp->codeproc) 363 refclock_samples_expire(pp, 1); 364 } 365 366 /* 367 * Initialize PPSAPI 368 */ 369 int 370 jupiter_ppsapi( 371 struct instance * const up /* unit structure pointer */ 372 ) 373 { 374 int capability; 375 376 if (time_pps_getcap(up->pps_handle, &capability) < 0) { 377 msyslog(LOG_ERR, 378 "refclock_jupiter: time_pps_getcap failed: %m"); 379 return (0); 380 } 381 memset(&up->pps_params, 0, sizeof(pps_params_t)); 382 if (!up->assert) 383 up->pps_params.mode = capability & PPS_CAPTURECLEAR; 384 else 385 up->pps_params.mode = capability & PPS_CAPTUREASSERT; 386 if (!(up->pps_params.mode & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR))) { 387 msyslog(LOG_ERR, 388 "refclock_jupiter: invalid capture edge %d", 389 up->assert); 390 return (0); 391 } 392 up->pps_params.mode |= PPS_TSFMT_TSPEC; 393 if (time_pps_setparams(up->pps_handle, &up->pps_params) < 0) { 394 msyslog(LOG_ERR, 395 "refclock_jupiter: time_pps_setparams failed: %m"); 396 return (0); 397 } 398 if (up->hardpps) { 399 if (time_pps_kcbind(up->pps_handle, PPS_KC_HARDPPS, 400 up->pps_params.mode & ~PPS_TSFMT_TSPEC, 401 PPS_TSFMT_TSPEC) < 0) { 402 msyslog(LOG_ERR, 403 "refclock_jupiter: time_pps_kcbind failed: %m"); 404 return (0); 405 } 406 hardpps_enable = 1; 407 } 408 /* up->peer->precision = PPS_PRECISION; */ 409 410 #if DEBUG 411 if (debug) { 412 time_pps_getparams(up->pps_handle, &up->pps_params); 413 jupiter_debug(up->peer, __func__, 414 "pps capability 0x%x version %d mode 0x%x kern %d", 415 capability, up->pps_params.api_version, 416 up->pps_params.mode, up->hardpps); 417 } 418 #endif 419 420 return (1); 421 } 422 423 /* 424 * Get PPSAPI timestamps. 425 * 426 * Return 0 on failure and 1 on success. 427 */ 428 static int 429 jupiter_pps(struct instance * const up) 430 { 431 pps_info_t pps_info; 432 struct timespec timeout, ts; 433 l_fp tstmp; 434 435 /* 436 * Convert the timespec nanoseconds field to ntp l_fp units. 437 */ 438 if (up->pps_handle == 0) 439 return 1; 440 timeout.tv_sec = 0; 441 timeout.tv_nsec = 0; 442 memcpy(&pps_info, &up->pps_info, sizeof(pps_info_t)); 443 if (time_pps_fetch(up->pps_handle, PPS_TSFMT_TSPEC, &up->pps_info, 444 &timeout) < 0) 445 return 1; 446 if (up->pps_params.mode & PPS_CAPTUREASSERT) { 447 if (pps_info.assert_sequence == 448 up->pps_info.assert_sequence) 449 return 1; 450 ts = up->pps_info.assert_timestamp; 451 } else if (up->pps_params.mode & PPS_CAPTURECLEAR) { 452 if (pps_info.clear_sequence == 453 up->pps_info.clear_sequence) 454 return 1; 455 ts = up->pps_info.clear_timestamp; 456 } else { 457 return 1; 458 } 459 460 tstmp = tspec_stamp_to_lfp(ts); 461 if (L_ISEQU(&tstmp, &up->rcv_pps)) 462 return 1; 463 464 up->rcv_pps = tstmp; 465 return 0; 466 } 467 468 /* 469 * jupiter_poll - jupiter watchdog routine 470 */ 471 static void 472 jupiter_poll(int unit, struct peer *peer) 473 { 474 struct refclockproc * const pp = peer->procptr; 475 struct instance * const up = pp->unitptr; 476 477 pp->polls++; 478 479 /* 480 * If we have new samples since last poll, everything is fine. 481 * if not, blarb loudly. 482 */ 483 if (pp->coderecv != pp->codeproc) { 484 refclock_receive(peer); 485 refclock_report(peer, CEVNT_NOMINAL); 486 } else { 487 refclock_report(peer, CEVNT_TIMEOUT); 488 489 /* Request the receiver id to trigger a reconfig */ 490 jupiter_reqonemsg(up, JUPITER_O_ID); 491 up->wantid = 0; 492 } 493 } 494 495 /* 496 * jupiter_control - fudge control 497 */ 498 static void 499 jupiter_control( 500 int unit, /* unit (not used) */ 501 const struct refclockstat *in, /* input parameters (not used) */ 502 struct refclockstat *out, /* output parameters (not used) */ 503 struct peer *peer /* peer structure pointer */ 504 ) 505 { 506 struct refclockproc * const pp = peer->procptr; 507 struct instance * const up = pp->unitptr; 508 509 u_char sloppyclockflag; 510 511 up->assert = !(pp->sloppyclockflag & CLK_FLAG3); 512 jupiter_ppsapi(up); 513 514 sloppyclockflag = up->sloppyclockflag; 515 up->sloppyclockflag = pp->sloppyclockflag; 516 if ((up->sloppyclockflag & CLK_FLAG2) != 517 (sloppyclockflag & CLK_FLAG2)) { 518 jupiter_debug(peer, __func__, 519 "mode switch: reset receiver"); 520 jupiter_config(up); 521 return; 522 } 523 } 524 525 /* 526 * jupiter_receive - receive gps data 527 * Gag me! 528 */ 529 static void 530 jupiter_receive(struct recvbuf * const rbufp) 531 { 532 struct peer * const peer = rbufp->recv_peer; 533 struct refclockproc * const pp = peer->procptr; 534 struct instance * const up = pp->unitptr; 535 536 size_t bpcnt; 537 int cc, size; 538 const char *cp; 539 u_char *bp; 540 u_short *sp; 541 struct jid *ip; 542 struct jheader *hp; 543 544 /* Initialize pointers and read the timecode and timestamp */ 545 bp = (u_char *)rbufp->recv_buffer; 546 bpcnt = rbufp->recv_length; 547 548 /* This shouldn't happen */ 549 if (bpcnt > sizeof(up->sbuf) - up->ssize) 550 bpcnt = sizeof(up->sbuf) - up->ssize; 551 552 /* Append to input buffer */ 553 memcpy((u_char *)up->sbuf + up->ssize, bp, bpcnt); 554 up->ssize += bpcnt; 555 556 /* While there's at least a header and we parse an intact message */ 557 while (up->ssize > (int)sizeof(*hp) && (cc = jupiter_recv(up)) > 0) { 558 hp = (struct jheader *)up->sbuf; 559 sp = (u_short *)(hp + 1); 560 size = cc - sizeof(*hp); 561 switch (getshort(hp->id)) { 562 563 case JUPITER_O_PULSE: 564 /* first see if we can push another sample: */ 565 jupiter_checkpps(pp, up); 566 567 if (size != sizeof(struct jpulse)) { 568 jupiter_debug(peer, __func__, 569 "pulse: len %d != %u", 570 size, (int)sizeof(struct jpulse)); 571 refclock_report(peer, CEVNT_BADREPLY); 572 break; 573 } 574 575 /* Parse timecode (even when there's no pps) 576 * 577 * There appears to be a firmware bug related to 578 * the pulse message; in addition to the one per 579 * second messages, we get an extra pulse 580 * message once an hour (on the anniversary of 581 * the cold start). It seems to come 200 ms 582 * after the one requested. 583 * 584 * But since we feed samples only when a new PPS 585 * pulse is found we can simply ignore that and 586 * aggregate/update any existing timing message. 587 */ 588 if ((cp = jupiter_parse_t(up, sp, rbufp->recv_time)) != NULL) { 589 jupiter_debug(peer, __func__, 590 "pulse: %s", cp); 591 } 592 break; 593 594 case JUPITER_O_GPOS: 595 if (size != sizeof(struct jgpos)) { 596 jupiter_debug(peer, __func__, 597 "gpos: len %d != %u", 598 size, (int)sizeof(struct jgpos)); 599 refclock_report(peer, CEVNT_BADREPLY); 600 break; 601 } 602 603 if ((cp = jupiter_parse_gpos(up, sp)) != NULL) { 604 jupiter_debug(peer, __func__, 605 "gpos: %s", cp); 606 break; 607 } 608 break; 609 610 case JUPITER_O_ID: 611 if (size != sizeof(struct jid)) { 612 jupiter_debug(peer, __func__, 613 "id: len %d != %u", 614 size, (int)sizeof(struct jid)); 615 refclock_report(peer, CEVNT_BADREPLY); 616 break; 617 } 618 /* 619 * If we got this message because the Jupiter 620 * just powered instance, it needs to be reconfigured. 621 */ 622 ip = (struct jid *)sp; 623 jupiter_debug(peer, __func__, 624 "%s chan ver %s, %s (%s)", 625 ip->chans, ip->vers, ip->date, ip->opts); 626 msyslog(LOG_DEBUG, 627 "jupiter_receive: %s chan ver %s, %s (%s)", 628 ip->chans, ip->vers, ip->date, ip->opts); 629 if (up->wantid) 630 up->wantid = 0; 631 else { 632 jupiter_debug(peer, __func__, "reset receiver"); 633 jupiter_config(up); 634 /* 635 * Restore since jupiter_config() just 636 * zeroed it 637 */ 638 up->ssize = cc; 639 } 640 break; 641 642 default: 643 jupiter_debug(peer, __func__, "unknown message id %d", 644 getshort(hp->id)); 645 break; 646 } 647 up->ssize -= cc; 648 if (up->ssize < 0) { 649 fprintf(stderr, "jupiter_recv: negative ssize!\n"); 650 abort(); 651 } else if (up->ssize > 0) 652 memcpy(up->sbuf, (u_char *)up->sbuf + cc, up->ssize); 653 } 654 } 655 656 static const char * 657 jupiter_parse_t( 658 struct instance * const up, 659 u_short * sp, 660 l_fp rcvtime 661 ) 662 { 663 struct jpulse *jp; 664 u_int32 sweek; 665 u_short flags; 666 l_fp fofs; 667 668 jp = (struct jpulse *)sp; 669 flags = getshort(jp->flags); 670 671 /* Toss if not designated "valid" by the gps. 672 * !!NOTE!! do *not* kill data received so far! 673 */ 674 if ((flags & JUPITER_O_PULSE_VALID) == 0) { 675 refclock_report(up->peer, CEVNT_BADTIME); 676 return ("time mark not valid"); 677 } 678 679 up->rcv_next = rcvtime; /* remember when this happened */ 680 681 /* The timecode is presented as seconds into the current GPS week */ 682 sweek = DS2UI(jp->sweek) % WEEKSECS; 683 /* check if we have to apply the UTC offset ourselves */ 684 if ((flags & JUPITER_O_PULSE_UTC) == 0) { 685 struct timespec tofs; 686 tofs.tv_sec = getshort(jp->offs); 687 tofs.tv_nsec = DS2I(jp->offns); 688 fofs = tspec_intv_to_lfp(tofs); 689 L_NEG(&fofs); 690 } else { 691 ZERO(fofs); 692 } 693 694 /* 695 * If we don't know the current GPS week, calculate it from the 696 * current time. (It's too bad they didn't include this 697 * important value in the pulse message). 698 * 699 * So we pick the pivot value from the other messages like gpos 700 * or chan if we can. Of course, the PULSE message can be in UTC 701 * or GPS time scale, and the other messages are simply always 702 * GPS time. 703 * 704 * But as long as the difference between the time stamps is less 705 * than a half week, the unfolding of a week time is unambigeous 706 * and well suited for the problem we have here. And we won't 707 * see *that* many leap seconds, ever. 708 */ 709 if (up->piv_next.weeks) { 710 up->ref_next = gpscal_from_weektime2( 711 sweek, fofs, &up->piv_next); 712 up->piv_next = up->ref_next; 713 } else { 714 up->ref_next = gpscal_from_weektime1( 715 sweek, fofs, rcvtime); 716 } 717 718 719 720 return (NULL); 721 } 722 723 static const char * 724 jupiter_parse_gpos( 725 struct instance * const up, 726 u_short * sp 727 ) 728 { 729 struct jgpos *jg; 730 struct calendar tref; 731 char *cp; 732 struct timespec tofs; 733 uint16_t raw_week; 734 uint32_t raw_secs; 735 736 jg = (struct jgpos *)sp; 737 738 if (jg->navval != 0) { 739 /* 740 * Solution not valid. Use caution and refuse 741 * to determine GPS week from this message. 742 */ 743 return ("Navigation solution not valid"); 744 } 745 746 raw_week = getshort(jg->gweek); 747 raw_secs = DS2UI(jg->sweek); 748 tofs.tv_sec = 0; 749 tofs.tv_nsec = DS2UI(jg->nsweek); 750 up->piv_next = gpscal_from_gpsweek(raw_week, raw_secs, 751 tspec_intv_to_lfp(tofs)); 752 up->piv_hold = 60; 753 754 gpscal_to_calendar(&tref, &up->piv_next); 755 cp = ntpcal_iso8601std(NULL, 0, &tref); 756 jupiter_debug(up->peer, __func__, 757 "GPS %s (gweek/sweek %hu/%u)", 758 cp, (unsigned short)raw_week, (unsigned int)raw_secs); 759 return (NULL); 760 } 761 762 /* 763 * jupiter_debug - print debug messages 764 */ 765 static void 766 jupiter_debug( 767 struct peer * peer, 768 const char * function, 769 const char * fmt, 770 ... 771 ) 772 { 773 char buffer[200]; 774 va_list ap; 775 776 va_start(ap, fmt); 777 /* 778 * Print debug message to stdout 779 * In the future, we may want to get get more creative... 780 */ 781 mvsnprintf(buffer, sizeof(buffer), fmt, ap); 782 record_clock_stats(&peer->srcadr, buffer); 783 #ifdef DEBUG 784 if (debug) { 785 printf("%s: %s\n", function, buffer); 786 fflush(stdout); 787 } 788 #endif 789 790 va_end(ap); 791 } 792 793 /* Checksum and transmit a message to the Jupiter */ 794 static char * 795 jupiter_send( 796 struct instance * const up, 797 struct jheader * hp 798 ) 799 { 800 u_int len, size; 801 ssize_t cc; 802 u_short *sp; 803 static char errstr[132]; 804 805 size = sizeof(*hp); 806 hp->hsum = putshort(jupiter_cksum((u_short *)hp, 807 (size / sizeof(u_short)) - 1)); 808 len = getshort(hp->len); 809 if (len > 0) { 810 sp = (u_short *)(hp + 1); 811 sp[len] = putshort(jupiter_cksum(sp, len)); 812 size += (len + 1) * sizeof(u_short); 813 } 814 815 if ((cc = write(up->peer->procptr->io.fd, (char *)hp, size)) < 0) { 816 msnprintf(errstr, sizeof(errstr), "write: %m"); 817 return (errstr); 818 } else if (cc != (int)size) { 819 snprintf(errstr, sizeof(errstr), "short write (%zd != %u)", cc, size); 820 return (errstr); 821 } 822 return (NULL); 823 } 824 825 /* Request periodic message output */ 826 static struct { 827 struct jheader jheader; 828 struct jrequest jrequest; 829 } reqmsg = { 830 { putshort(JUPITER_SYNC), 0, 831 putshort((sizeof(struct jrequest) / sizeof(u_short)) - 1), 832 0, JUPITER_FLAG_REQUEST | JUPITER_FLAG_NAK | 833 JUPITER_FLAG_CONN | JUPITER_FLAG_LOG, 0 }, 834 { 0, 0, 0, 0 } 835 }; 836 837 /* An interval of zero means to output on trigger */ 838 static void 839 jupiter_reqmsg( 840 struct instance * const up, 841 u_int id, 842 u_int interval 843 ) 844 { 845 struct jheader *hp; 846 struct jrequest *rp; 847 char *cp; 848 849 hp = &reqmsg.jheader; 850 hp->id = putshort(id); 851 rp = &reqmsg.jrequest; 852 rp->trigger = putshort(interval == 0); 853 rp->interval = putshort(interval); 854 if ((cp = jupiter_send(up, hp)) != NULL) 855 jupiter_debug(up->peer, __func__, "%u: %s", id, cp); 856 } 857 858 /* Cancel periodic message output */ 859 static struct jheader canmsg = { 860 putshort(JUPITER_SYNC), 0, 0, 0, 861 JUPITER_FLAG_REQUEST | JUPITER_FLAG_NAK | JUPITER_FLAG_DISC, 862 0 863 }; 864 865 static void 866 jupiter_canmsg( 867 struct instance * const up, 868 u_int id 869 ) 870 { 871 struct jheader *hp; 872 char *cp; 873 874 hp = &canmsg; 875 hp->id = putshort(id); 876 if ((cp = jupiter_send(up, hp)) != NULL) 877 jupiter_debug(up->peer, __func__, "%u: %s", id, cp); 878 } 879 880 /* Request a single message output */ 881 static struct jheader reqonemsg = { 882 putshort(JUPITER_SYNC), 0, 0, 0, 883 JUPITER_FLAG_REQUEST | JUPITER_FLAG_NAK | JUPITER_FLAG_QUERY, 884 0 885 }; 886 887 static void 888 jupiter_reqonemsg( 889 struct instance * const up, 890 u_int id 891 ) 892 { 893 struct jheader *hp; 894 char *cp; 895 896 hp = &reqonemsg; 897 hp->id = putshort(id); 898 if ((cp = jupiter_send(up, hp)) != NULL) 899 jupiter_debug(up->peer, __func__, "%u: %s", id, cp); 900 } 901 902 /* Set the platform dynamics */ 903 static struct { 904 struct jheader jheader; 905 struct jplat jplat; 906 } platmsg = { 907 { putshort(JUPITER_SYNC), putshort(JUPITER_I_PLAT), 908 putshort((sizeof(struct jplat) / sizeof(u_short)) - 1), 0, 909 JUPITER_FLAG_REQUEST | JUPITER_FLAG_NAK, 0 }, 910 { 0, 0, 0 } 911 }; 912 913 static void 914 jupiter_platform( 915 struct instance * const up, 916 u_int platform 917 ) 918 { 919 struct jheader *hp; 920 struct jplat *pp; 921 char *cp; 922 923 hp = &platmsg.jheader; 924 pp = &platmsg.jplat; 925 pp->platform = putshort(platform); 926 if ((cp = jupiter_send(up, hp)) != NULL) 927 jupiter_debug(up->peer, __func__, "%u: %s", platform, cp); 928 } 929 930 /* Checksum "len" shorts */ 931 static u_short 932 jupiter_cksum(u_short *sp, u_int len) 933 { 934 u_short sum, x; 935 936 sum = 0; 937 while (len-- > 0) { 938 x = *sp++; 939 sum += getshort(x); 940 } 941 return (~sum + 1); 942 } 943 944 /* Return the size of the next message (or zero if we don't have it all yet) */ 945 static int 946 jupiter_recv( 947 struct instance * const up 948 ) 949 { 950 int n, len, size, cc; 951 struct jheader *hp; 952 u_char *bp; 953 u_short *sp; 954 955 /* Must have at least a header's worth */ 956 cc = sizeof(*hp); 957 size = up->ssize; 958 if (size < cc) 959 return (0); 960 961 /* Search for the sync short if missing */ 962 sp = up->sbuf; 963 hp = (struct jheader *)sp; 964 if (getshort(hp->sync) != JUPITER_SYNC) { 965 /* Wasn't at the front, sync up */ 966 jupiter_debug(up->peer, __func__, "syncing"); 967 bp = (u_char *)sp; 968 n = size; 969 while (n >= 2) { 970 if (bp[0] != (JUPITER_SYNC & 0xff)) { 971 /* 972 jupiter_debug(up->peer, __func__, 973 "{0x%x}", bp[0]); 974 */ 975 ++bp; 976 --n; 977 continue; 978 } 979 if (bp[1] == ((JUPITER_SYNC >> 8) & 0xff)) 980 break; 981 /* 982 jupiter_debug(up->peer, __func__, 983 "{0x%x 0x%x}", bp[0], bp[1]); 984 */ 985 bp += 2; 986 n -= 2; 987 } 988 /* 989 jupiter_debug(up->peer, __func__, "\n"); 990 */ 991 /* Shuffle data to front of input buffer */ 992 if (n > 0) 993 memcpy(sp, bp, n); 994 size = n; 995 up->ssize = size; 996 if (size < cc || hp->sync != JUPITER_SYNC) 997 return (0); 998 } 999 1000 if (jupiter_cksum(sp, (cc / sizeof(u_short) - 1)) != 1001 getshort(hp->hsum)) { 1002 jupiter_debug(up->peer, __func__, "bad header checksum!"); 1003 /* This is drastic but checksum errors should be rare */ 1004 up->ssize = 0; 1005 return (0); 1006 } 1007 1008 /* Check for a payload */ 1009 len = getshort(hp->len); 1010 if (len > 0) { 1011 n = (len + 1) * sizeof(u_short); 1012 /* Not enough data yet */ 1013 if (size < cc + n) 1014 return (0); 1015 1016 /* Check payload checksum */ 1017 sp = (u_short *)(hp + 1); 1018 if (jupiter_cksum(sp, len) != getshort(sp[len])) { 1019 jupiter_debug(up->peer, 1020 __func__, "bad payload checksum!"); 1021 /* This is drastic but checksum errors should be rare */ 1022 up->ssize = 0; 1023 return (0); 1024 } 1025 cc += n; 1026 } 1027 return (cc); 1028 } 1029 1030 #else /* not (REFCLOCK && CLOCK_JUPITER && HAVE_PPSAPI) */ 1031 int refclock_jupiter_bs; 1032 #endif /* not (REFCLOCK && CLOCK_JUPITER && HAVE_PPSAPI) */ 1033