refclock_jupiter.c revision 344884
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 WORDS_BIGENDIAN 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) ((u_short)(s)) 60#define putshort(s) ((u_short)(s)) 61#endif 62 63/* 64 * This driver supports the Rockwell Jupiter GPS Receiver board 65 * adapted to precision timing applications. It requires the 66 * ppsclock line discipline or streams module described in the 67 * Line Disciplines and Streams Drivers page. It also requires a 68 * gadget box and 1-PPS level converter, such as described in the 69 * Pulse-per-second (PPS) Signal Interfacing page. 70 * 71 * It may work (with minor modifications) with other Rockwell GPS 72 * receivers such as the CityTracker. 73 */ 74 75/* 76 * GPS Definitions 77 */ 78#define DEVICE "/dev/gps%d" /* device name and unit */ 79#define SPEED232 B9600 /* baud */ 80 81/* 82 * Radio interface parameters 83 */ 84#define PRECISION (-18) /* precision assumed (about 4 us) */ 85#define REFID "GPS\0" /* reference id */ 86#define DESCRIPTION "Rockwell Jupiter GPS Receiver" /* who we are */ 87#define DEFFUDGETIME 0 /* default fudge time (ms) */ 88 89/* Unix timestamp for the GPS epoch: January 6, 1980 */ 90#define GPS_EPOCH 315964800 91 92/* Rata Die Number of first day of GPS epoch. This is the number of days 93 * since 0000-12-31 to 1980-01-06 in the proleptic Gregorian Calendar. 94 */ 95#define RDN_GPS_EPOCH (4*146097 + 138431 + 1) 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 */ 109struct 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 */ 138static void jupiter_canmsg (struct instance *, u_int); 139static u_short jupiter_cksum (u_short *, u_int); 140static int jupiter_config (struct instance *); 141static void jupiter_debug (struct peer *, const char *, 142 const char *, ...) NTP_PRINTF(3, 4); 143static const char * jupiter_parse_t (struct instance *, u_short *); 144static const char * jupiter_parse_gpos (struct instance *, u_short *); 145static void jupiter_platform (struct instance *, u_int); 146static void jupiter_poll (int, struct peer *); 147static void jupiter_control (int, const struct refclockstat *, 148 struct refclockstat *, struct peer *); 149#ifdef HAVE_PPSAPI 150static int jupiter_ppsapi (struct instance *); 151static int jupiter_pps (struct instance *); 152#endif /* HAVE_PPSAPI */ 153static int jupiter_recv (struct instance *); 154static void jupiter_receive (struct recvbuf *rbufp); 155static void jupiter_reqmsg (struct instance *, u_int, u_int); 156static void jupiter_reqonemsg(struct instance *, u_int); 157static char * jupiter_send (struct instance *, struct jheader *); 158static void jupiter_shutdown(int, struct peer *); 159static int jupiter_start (int, struct peer *); 160 161/* 162 * Transfer vector 163 */ 164struct 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 */ 177static int 178jupiter_start( 179 int unit, 180 struct peer *peer 181 ) 182{ 183 struct refclockproc *pp; 184 struct instance *instance; 185 int fd; 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: %m", 195 gpsdev); 196 return (0); 197 } 198 199 /* Allocate unit structure */ 200 instance = emalloc_zero(sizeof(*instance)); 201 instance->peer = peer; 202 pp = peer->procptr; 203 pp->io.clock_recv = jupiter_receive; 204 pp->io.srcclock = peer; 205 pp->io.datalen = 0; 206 pp->io.fd = fd; 207 if (!io_addclock(&pp->io)) { 208 close(fd); 209 pp->io.fd = -1; 210 free(instance); 211 return (0); 212 } 213 pp->unitptr = 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 244clean_up: 245 jupiter_shutdown(unit, peer); 246 pp->unitptr = 0; 247 return (0); 248} 249 250/* 251 * jupiter_shutdown - shut down the clock 252 */ 253static void 254jupiter_shutdown(int unit, struct peer *peer) 255{ 256 struct instance *instance; 257 struct refclockproc *pp; 258 259 pp = peer->procptr; 260 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 if (pp->io.fd != -1) 272 io_closeclock(&pp->io); 273 free(instance); 274} 275 276/* 277 * jupiter_config - Configure the receiver 278 */ 279static int 280jupiter_config(struct instance *instance) 281{ 282 jupiter_debug(instance->peer, __func__, "init receiver"); 283 284 /* 285 * Initialize the unit variables 286 */ 287 instance->sloppyclockflag = instance->peer->procptr->sloppyclockflag; 288 instance->moving = !!(instance->sloppyclockflag & CLK_FLAG2); 289 if (instance->moving) 290 jupiter_debug(instance->peer, __func__, "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 */ 330int 331jupiter_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 hardpps_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, __func__, 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 */ 389static int 390jupiter_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 = (u_int32)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 */ 436static void 437jupiter_poll(int unit, struct peer *peer) 438{ 439 struct instance *instance; 440 struct refclockproc *pp; 441 442 pp = peer->procptr; 443 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 */ 475static void 476jupiter_control( 477 int unit, /* unit (not used) */ 478 const 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 = 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, __func__, 505 "mode switch: reset receiver"); 506 jupiter_config(instance); 507 return; 508 } 509} 510 511/* 512 * jupiter_receive - receive gps data 513 * Gag me! 514 */ 515static void 516jupiter_receive(struct recvbuf *rbufp) 517{ 518 size_t bpcnt; 519 int cc, size, ppsret; 520 time_t last_timecode; 521 u_int32 laststime; 522 const 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 = rbufp->recv_peer; 534 pp = peer->procptr; 535 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 > (int)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, __func__, 561 "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, __func__, 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, __func__, 602 "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 + (u_int32)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, __func__, 652 "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, __func__, 660 "gpos: %s", cp); 661 break; 662 } 663 break; 664 665 case JUPITER_O_ID: 666 if (size != sizeof(struct jid)) { 667 jupiter_debug(peer, __func__, 668 "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, __func__, 679 "%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, __func__, "reset receiver"); 688 jupiter_config(instance); 689 /* 690 * Restore since jupiter_config() just 691 * zeroed it 692 */ 693 instance->ssize = cc; 694 } 695 break; 696 697 default: 698 jupiter_debug(peer, __func__, "unknown message id %d", 699 getshort(hp->id)); 700 break; 701 } 702 instance->ssize -= cc; 703 if (instance->ssize < 0) { 704 fprintf(stderr, "jupiter_recv: negative ssize!\n"); 705 abort(); 706 } else if (instance->ssize > 0) 707 memcpy(instance->sbuf, (u_char *)instance->sbuf + cc, instance->ssize); 708 } 709} 710 711static const char * 712jupiter_parse_t(struct instance *instance, u_short *sp) 713{ 714 struct tm *tm; 715 char *cp; 716 struct jpulse *jp; 717 u_int32 sweek; 718 time_t last_timecode; 719 u_short flags; 720 721 jp = (struct jpulse *)sp; 722 723 /* The timecode is presented as seconds into the current GPS week */ 724 sweek = DS2UI(jp->sweek) % WEEKSECS; 725 726 /* 727 * If we don't know the current GPS week, calculate it from the 728 * current time. (It's too bad they didn't include this 729 * important value in the pulse message). We'd like to pick it 730 * up from one of the other messages like gpos or chan but they 731 * don't appear to be synchronous with time keeping and changes 732 * too soon (something like 10 seconds before the new GPS 733 * week). 734 * 735 * If we already know the current GPS week, increment it when 736 * we wrap into a new week. 737 */ 738 if (instance->gweek == 0) { 739 if (!instance->gpos_gweek) { 740 return ("jupiter_parse_t: Unknown gweek"); 741 } 742 743 instance->gweek = instance->gpos_gweek; 744 745 /* 746 * Fix warps. GPOS has GPS time and PULSE has UTC. 747 * Plus, GPOS need not be completely in synch with 748 * the PPS signal. 749 */ 750 if (instance->gpos_sweek >= sweek) { 751 if ((instance->gpos_sweek - sweek) > WEEKSECS / 2) 752 ++instance->gweek; 753 } 754 else { 755 if ((sweek - instance->gpos_sweek) > WEEKSECS / 2) 756 --instance->gweek; 757 } 758 } 759 else if (sweek == 0 && instance->lastsweek == WEEKSECS - 1) { 760 ++instance->gweek; 761 jupiter_debug(instance->peer, __func__, 762 "NEW gps week %u", instance->gweek); 763 } 764 765 /* 766 * See if the sweek stayed the same (this happens when there is 767 * no pps pulse). 768 * 769 * Otherwise, look for time warps: 770 * 771 * - we have stored at least one lastsweek and 772 * - the sweek didn't increase by one and 773 * - we didn't wrap to a new GPS week 774 * 775 * Then we warped. 776 */ 777 if (instance->lastsweek == sweek) 778 jupiter_debug(instance->peer, __func__, 779 "gps sweek not incrementing (%d)", 780 sweek); 781 else if (instance->lastsweek != 2 * WEEKSECS && 782 instance->lastsweek + 1 != sweek && 783 !(sweek == 0 && instance->lastsweek == WEEKSECS - 1)) 784 jupiter_debug(instance->peer, __func__, 785 "gps sweek jumped (was %d, now %d)", 786 instance->lastsweek, sweek); 787 instance->lastsweek = sweek; 788 789 /* This timecode describes next pulse */ 790 last_timecode = instance->timecode; 791 instance->timecode = 792 GPS_EPOCH + (instance->gweek * WEEKSECS) + sweek; 793 794 if (last_timecode == 0) 795 /* XXX debugging */ 796 jupiter_debug(instance->peer, __func__, 797 "UTC <none> (gweek/sweek %u/%u)", 798 instance->gweek, sweek); 799 else { 800 /* XXX debugging */ 801 tm = gmtime(&last_timecode); 802 cp = asctime(tm); 803 804 jupiter_debug(instance->peer, __func__, 805 "UTC %.24s (gweek/sweek %u/%u)", 806 cp, instance->gweek, sweek); 807 808 /* Billboard last_timecode (which is now the current time) */ 809 instance->peer->procptr->year = tm->tm_year + 1900; 810 instance->peer->procptr->day = tm->tm_yday + 1; 811 instance->peer->procptr->hour = tm->tm_hour; 812 instance->peer->procptr->minute = tm->tm_min; 813 instance->peer->procptr->second = tm->tm_sec; 814 } 815 816 flags = getshort(jp->flags); 817 818 /* Toss if not designated "valid" by the gps */ 819 if ((flags & JUPITER_O_PULSE_VALID) == 0) { 820 refclock_report(instance->peer, CEVNT_BADTIME); 821 return ("time mark not valid"); 822 } 823 824 /* We better be sync'ed to UTC... */ 825 if ((flags & JUPITER_O_PULSE_UTC) == 0) { 826 refclock_report(instance->peer, CEVNT_BADTIME); 827 return ("time mark not sync'ed to UTC"); 828 } 829 830 return (NULL); 831} 832 833static const char * 834jupiter_parse_gpos(struct instance *instance, u_short *sp) 835{ 836 struct jgpos *jg; 837 time_t t; 838 struct tm *tm; 839 char *cp; 840 841 jg = (struct jgpos *)sp; 842 843 if (jg->navval != 0) { 844 /* 845 * Solution not valid. Use caution and refuse 846 * to determine GPS week from this message. 847 */ 848 instance->gpos_gweek = 0; 849 instance->gpos_sweek = 0; 850 return ("Navigation solution not valid"); 851 } 852 853 instance->gpos_sweek = DS2UI(jg->sweek); 854 instance->gpos_gweek = basedate_expand_gpsweek(getshort(jg->gweek)); 855 856 /* according to the protocol spec, the seconds-in-week cannot 857 * exceed the nominal value: Is it really necessary to normalise 858 * the seconds??? 859 */ 860 while(instance->gpos_sweek >= WEEKSECS) { 861 instance->gpos_sweek -= WEEKSECS; 862 ++instance->gpos_gweek; 863 } 864 instance->gweek = 0; 865 866 t = GPS_EPOCH + (instance->gpos_gweek * WEEKSECS) + instance->gpos_sweek; 867 tm = gmtime(&t); 868 cp = asctime(tm); 869 870 jupiter_debug(instance->peer, __func__, 871 "GPS %.24s (gweek/sweek %u/%u)", 872 cp, instance->gpos_gweek, instance->gpos_sweek); 873 return (NULL); 874} 875 876/* 877 * jupiter_debug - print debug messages 878 */ 879static void 880jupiter_debug( 881 struct peer * peer, 882 const char * function, 883 const char * fmt, 884 ... 885 ) 886{ 887 char buffer[200]; 888 va_list ap; 889 890 va_start(ap, fmt); 891 /* 892 * Print debug message to stdout 893 * In the future, we may want to get get more creative... 894 */ 895 mvsnprintf(buffer, sizeof(buffer), fmt, ap); 896 record_clock_stats(&peer->srcadr, buffer); 897#ifdef DEBUG 898 if (debug) { 899 printf("%s: %s\n", function, buffer); 900 fflush(stdout); 901 } 902#endif 903 904 va_end(ap); 905} 906 907/* Checksum and transmit a message to the Jupiter */ 908static char * 909jupiter_send(struct instance *instance, struct jheader *hp) 910{ 911 u_int len, size; 912 ssize_t cc; 913 u_short *sp; 914 static char errstr[132]; 915 916 size = sizeof(*hp); 917 hp->hsum = putshort(jupiter_cksum((u_short *)hp, 918 (size / sizeof(u_short)) - 1)); 919 len = getshort(hp->len); 920 if (len > 0) { 921 sp = (u_short *)(hp + 1); 922 sp[len] = putshort(jupiter_cksum(sp, len)); 923 size += (len + 1) * sizeof(u_short); 924 } 925 926 if ((cc = write(instance->peer->procptr->io.fd, (char *)hp, size)) < 0) { 927 msnprintf(errstr, sizeof(errstr), "write: %m"); 928 return (errstr); 929 } else if (cc != (int)size) { 930 snprintf(errstr, sizeof(errstr), "short write (%zd != %u)", cc, size); 931 return (errstr); 932 } 933 return (NULL); 934} 935 936/* Request periodic message output */ 937static struct { 938 struct jheader jheader; 939 struct jrequest jrequest; 940} reqmsg = { 941 { putshort(JUPITER_SYNC), 0, 942 putshort((sizeof(struct jrequest) / sizeof(u_short)) - 1), 943 0, JUPITER_FLAG_REQUEST | JUPITER_FLAG_NAK | 944 JUPITER_FLAG_CONN | JUPITER_FLAG_LOG, 0 }, 945 { 0, 0, 0, 0 } 946}; 947 948/* An interval of zero means to output on trigger */ 949static void 950jupiter_reqmsg(struct instance *instance, u_int id, 951 u_int interval) 952{ 953 struct jheader *hp; 954 struct jrequest *rp; 955 char *cp; 956 957 hp = &reqmsg.jheader; 958 hp->id = putshort(id); 959 rp = &reqmsg.jrequest; 960 rp->trigger = putshort(interval == 0); 961 rp->interval = putshort(interval); 962 if ((cp = jupiter_send(instance, hp)) != NULL) 963 jupiter_debug(instance->peer, __func__, "%u: %s", id, cp); 964} 965 966/* Cancel periodic message output */ 967static struct jheader canmsg = { 968 putshort(JUPITER_SYNC), 0, 0, 0, 969 JUPITER_FLAG_REQUEST | JUPITER_FLAG_NAK | JUPITER_FLAG_DISC, 970 0 971}; 972 973static void 974jupiter_canmsg(struct instance *instance, u_int id) 975{ 976 struct jheader *hp; 977 char *cp; 978 979 hp = &canmsg; 980 hp->id = putshort(id); 981 if ((cp = jupiter_send(instance, hp)) != NULL) 982 jupiter_debug(instance->peer, __func__, "%u: %s", id, cp); 983} 984 985/* Request a single message output */ 986static struct jheader reqonemsg = { 987 putshort(JUPITER_SYNC), 0, 0, 0, 988 JUPITER_FLAG_REQUEST | JUPITER_FLAG_NAK | JUPITER_FLAG_QUERY, 989 0 990}; 991 992static void 993jupiter_reqonemsg(struct instance *instance, u_int id) 994{ 995 struct jheader *hp; 996 char *cp; 997 998 hp = &reqonemsg; 999 hp->id = putshort(id); 1000 if ((cp = jupiter_send(instance, hp)) != NULL) 1001 jupiter_debug(instance->peer, __func__, "%u: %s", id, cp); 1002} 1003 1004/* Set the platform dynamics */ 1005static struct { 1006 struct jheader jheader; 1007 struct jplat jplat; 1008} platmsg = { 1009 { putshort(JUPITER_SYNC), putshort(JUPITER_I_PLAT), 1010 putshort((sizeof(struct jplat) / sizeof(u_short)) - 1), 0, 1011 JUPITER_FLAG_REQUEST | JUPITER_FLAG_NAK, 0 }, 1012 { 0, 0, 0 } 1013}; 1014 1015static void 1016jupiter_platform(struct instance *instance, u_int platform) 1017{ 1018 struct jheader *hp; 1019 struct jplat *pp; 1020 char *cp; 1021 1022 hp = &platmsg.jheader; 1023 pp = &platmsg.jplat; 1024 pp->platform = putshort(platform); 1025 if ((cp = jupiter_send(instance, hp)) != NULL) 1026 jupiter_debug(instance->peer, __func__, "%u: %s", platform, cp); 1027} 1028 1029/* Checksum "len" shorts */ 1030static u_short 1031jupiter_cksum(u_short *sp, u_int len) 1032{ 1033 u_short sum, x; 1034 1035 sum = 0; 1036 while (len-- > 0) { 1037 x = *sp++; 1038 sum += getshort(x); 1039 } 1040 return (~sum + 1); 1041} 1042 1043/* Return the size of the next message (or zero if we don't have it all yet) */ 1044static int 1045jupiter_recv(struct instance *instance) 1046{ 1047 int n, len, size, cc; 1048 struct jheader *hp; 1049 u_char *bp; 1050 u_short *sp; 1051 1052 /* Must have at least a header's worth */ 1053 cc = sizeof(*hp); 1054 size = instance->ssize; 1055 if (size < cc) 1056 return (0); 1057 1058 /* Search for the sync short if missing */ 1059 sp = instance->sbuf; 1060 hp = (struct jheader *)sp; 1061 if (getshort(hp->sync) != JUPITER_SYNC) { 1062 /* Wasn't at the front, sync up */ 1063 jupiter_debug(instance->peer, __func__, "syncing"); 1064 bp = (u_char *)sp; 1065 n = size; 1066 while (n >= 2) { 1067 if (bp[0] != (JUPITER_SYNC & 0xff)) { 1068 /* 1069 jupiter_debug(instance->peer, __func__, 1070 "{0x%x}", bp[0]); 1071 */ 1072 ++bp; 1073 --n; 1074 continue; 1075 } 1076 if (bp[1] == ((JUPITER_SYNC >> 8) & 0xff)) 1077 break; 1078 /* 1079 jupiter_debug(instance->peer, __func__, 1080 "{0x%x 0x%x}", bp[0], bp[1]); 1081 */ 1082 bp += 2; 1083 n -= 2; 1084 } 1085 /* 1086 jupiter_debug(instance->peer, __func__, "\n"); 1087 */ 1088 /* Shuffle data to front of input buffer */ 1089 if (n > 0) 1090 memcpy(sp, bp, n); 1091 size = n; 1092 instance->ssize = size; 1093 if (size < cc || hp->sync != JUPITER_SYNC) 1094 return (0); 1095 } 1096 1097 if (jupiter_cksum(sp, (cc / sizeof(u_short) - 1)) != 1098 getshort(hp->hsum)) { 1099 jupiter_debug(instance->peer, __func__, "bad header checksum!"); 1100 /* This is drastic but checksum errors should be rare */ 1101 instance->ssize = 0; 1102 return (0); 1103 } 1104 1105 /* Check for a payload */ 1106 len = getshort(hp->len); 1107 if (len > 0) { 1108 n = (len + 1) * sizeof(u_short); 1109 /* Not enough data yet */ 1110 if (size < cc + n) 1111 return (0); 1112 1113 /* Check payload checksum */ 1114 sp = (u_short *)(hp + 1); 1115 if (jupiter_cksum(sp, len) != getshort(sp[len])) { 1116 jupiter_debug(instance->peer, 1117 __func__, "bad payload checksum!"); 1118 /* This is drastic but checksum errors should be rare */ 1119 instance->ssize = 0; 1120 return (0); 1121 } 1122 cc += n; 1123 } 1124 return (cc); 1125} 1126 1127#else /* not (REFCLOCK && CLOCK_JUPITER && HAVE_PPSAPI) */ 1128int refclock_jupiter_bs; 1129#endif /* not (REFCLOCK && CLOCK_JUPITER && HAVE_PPSAPI) */ 1130