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 */
109 struct instance {
110 struct peer *peer; /* peer */
111 u_int pollcnt; /* poll message counter */
112 u_int polled; /* Hand in a time sample? */
113 #ifdef HAVE_PPSAPI
114 pps_params_t pps_params; /* pps parameters */
115 pps_info_t pps_info; /* last pps data */
116 pps_handle_t pps_handle; /* pps handle */
117 u_int assert; /* pps edge to use */
118 u_int hardpps; /* enable kernel mode */
119 struct timespec ts; /* last timestamp */
120 #endif
121 l_fp limit;
122 u_int gpos_gweek; /* Current GPOS GPS week number */
123 u_int gpos_sweek; /* Current GPOS GPS seconds into week */
124 u_int gweek; /* current GPS week number */
125 u_int32 lastsweek; /* last seconds into GPS week */
126 time_t timecode; /* current ntp timecode */
127 u_int32 stime; /* used to detect firmware bug */
128 int wantid; /* don't reconfig on channel id msg */
129 u_int moving; /* mobile platform? */
130 u_char sloppyclockflag; /* fudge flags */
131 u_short sbuf[512]; /* local input buffer */
132 int ssize; /* space used in sbuf */
133 };
134
135 /*
136 * Function prototypes
137 */
138 static void jupiter_canmsg (struct instance *, u_int);
139 static u_short jupiter_cksum (u_short *, u_int);
140 static int jupiter_config (struct instance *);
141 static void jupiter_debug (struct peer *, const char *,
142 const char *, ...) NTP_PRINTF(3, 4);
143 static const char * jupiter_parse_t (struct instance *, u_short *);
144 static const char * jupiter_parse_gpos (struct instance *, u_short *);
145 static void jupiter_platform (struct instance *, u_int);
146 static void jupiter_poll (int, struct peer *);
147 static void jupiter_control (int, const struct refclockstat *,
148 struct refclockstat *, struct peer *);
149 #ifdef HAVE_PPSAPI
150 static int jupiter_ppsapi (struct instance *);
151 static int jupiter_pps (struct instance *);
152 #endif /* HAVE_PPSAPI */
153 static int jupiter_recv (struct instance *);
154 static void jupiter_receive (struct recvbuf *rbufp);
155 static void jupiter_reqmsg (struct instance *, u_int, u_int);
156 static void jupiter_reqonemsg(struct instance *, u_int);
157 static char * jupiter_send (struct instance *, struct jheader *);
158 static void jupiter_shutdown(int, struct peer *);
159 static int jupiter_start (int, struct peer *);
160
161 static u_int get_full_week(u_int base_week, u_int gpos_week);
162 static u_int get_base_week(void);
163
164
165 /*
166 * Transfer vector
167 */
168 struct refclock refclock_jupiter = {
169 jupiter_start, /* start up driver */
170 jupiter_shutdown, /* shut down driver */
171 jupiter_poll, /* transmit poll message */
172 jupiter_control, /* (clock control) */
173 noentry, /* (clock init) */
174 noentry, /* (clock buginfo) */
175 NOFLAGS /* not used */
176 };
177
178 /*
179 * jupiter_start - open the devices and initialize data for processing
180 */
181 static int
jupiter_start(int unit,struct peer * peer)182 jupiter_start(
183 int unit,
184 struct peer *peer
185 )
186 {
187 struct refclockproc *pp;
188 struct instance *instance;
189 int fd;
190 char gpsdev[20];
191
192 /*
193 * Open serial port
194 */
195 snprintf(gpsdev, sizeof(gpsdev), DEVICE, unit);
196 fd = refclock_open(gpsdev, SPEED232, LDISC_RAW);
197 if (fd <= 0) {
198 jupiter_debug(peer, "jupiter_start", "open %s: %m",
199 gpsdev);
200 return (0);
201 }
202
203 /* Allocate unit structure */
204 instance = emalloc_zero(sizeof(*instance));
205 instance->peer = peer;
206 pp = peer->procptr;
207 pp->io.clock_recv = jupiter_receive;
208 pp->io.srcclock = peer;
209 pp->io.datalen = 0;
210 pp->io.fd = fd;
211 if (!io_addclock(&pp->io)) {
212 close(fd);
213 pp->io.fd = -1;
214 free(instance);
215 return (0);
216 }
217 pp->unitptr = instance;
218
219 /*
220 * Initialize miscellaneous variables
221 */
222 peer->precision = PRECISION;
223 pp->clockdesc = DESCRIPTION;
224 memcpy((char *)&pp->refid, REFID, 4);
225
226 #ifdef HAVE_PPSAPI
227 instance->assert = 1;
228 instance->hardpps = 0;
229 /*
230 * Start the PPSAPI interface if it is there. Default to use
231 * the assert edge and do not enable the kernel hardpps.
232 */
233 if (time_pps_create(fd, &instance->pps_handle) < 0) {
234 instance->pps_handle = 0;
235 msyslog(LOG_ERR,
236 "refclock_jupiter: time_pps_create failed: %m");
237 }
238 else if (!jupiter_ppsapi(instance))
239 goto clean_up;
240 #endif /* HAVE_PPSAPI */
241
242 /* Ensure the receiver is properly configured */
243 if (!jupiter_config(instance))
244 goto clean_up;
245
246 return (1);
247
248 clean_up:
249 jupiter_shutdown(unit, peer);
250 pp->unitptr = 0;
251 return (0);
252 }
253
254 /*
255 * jupiter_shutdown - shut down the clock
256 */
257 static void
jupiter_shutdown(int unit,struct peer * peer)258 jupiter_shutdown(int unit, struct peer *peer)
259 {
260 struct instance *instance;
261 struct refclockproc *pp;
262
263 pp = peer->procptr;
264 instance = pp->unitptr;
265 if (!instance)
266 return;
267
268 #ifdef HAVE_PPSAPI
269 if (instance->pps_handle) {
270 time_pps_destroy(instance->pps_handle);
271 instance->pps_handle = 0;
272 }
273 #endif /* HAVE_PPSAPI */
274
275 if (pp->io.fd != -1)
276 io_closeclock(&pp->io);
277 free(instance);
278 }
279
280 /*
281 * jupiter_config - Configure the receiver
282 */
283 static int
jupiter_config(struct instance * instance)284 jupiter_config(struct instance *instance)
285 {
286 jupiter_debug(instance->peer, __func__, "init receiver");
287
288 /*
289 * Initialize the unit variables
290 */
291 instance->sloppyclockflag = instance->peer->procptr->sloppyclockflag;
292 instance->moving = !!(instance->sloppyclockflag & CLK_FLAG2);
293 if (instance->moving)
294 jupiter_debug(instance->peer, __func__, "mobile platform");
295
296 instance->pollcnt = 2;
297 instance->polled = 0;
298 instance->gpos_gweek = 0;
299 instance->gpos_sweek = 0;
300 instance->gweek = 0;
301 instance->lastsweek = 2 * WEEKSECS;
302 instance->timecode = 0;
303 instance->stime = 0;
304 instance->ssize = 0;
305
306 /* Stop outputting all messages */
307 jupiter_canmsg(instance, JUPITER_ALL);
308
309 /* Request the receiver id so we can syslog the firmware version */
310 jupiter_reqonemsg(instance, JUPITER_O_ID);
311
312 /* Flag that this the id was requested (so we don't get called again) */
313 instance->wantid = 1;
314
315 /* Request perodic time mark pulse messages */
316 jupiter_reqmsg(instance, JUPITER_O_PULSE, 1);
317
318 /* Request perodic geodetic position status */
319 jupiter_reqmsg(instance, JUPITER_O_GPOS, 1);
320
321 /* Set application platform type */
322 if (instance->moving)
323 jupiter_platform(instance, JUPITER_I_PLAT_MED);
324 else
325 jupiter_platform(instance, JUPITER_I_PLAT_LOW);
326
327 return (1);
328 }
329
330 #ifdef HAVE_PPSAPI
331 /*
332 * Initialize PPSAPI
333 */
334 int
jupiter_ppsapi(struct instance * instance)335 jupiter_ppsapi(
336 struct instance *instance /* unit structure pointer */
337 )
338 {
339 int capability;
340
341 if (time_pps_getcap(instance->pps_handle, &capability) < 0) {
342 msyslog(LOG_ERR,
343 "refclock_jupiter: time_pps_getcap failed: %m");
344 return (0);
345 }
346 memset(&instance->pps_params, 0, sizeof(pps_params_t));
347 if (!instance->assert)
348 instance->pps_params.mode = capability & PPS_CAPTURECLEAR;
349 else
350 instance->pps_params.mode = capability & PPS_CAPTUREASSERT;
351 if (!(instance->pps_params.mode & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR))) {
352 msyslog(LOG_ERR,
353 "refclock_jupiter: invalid capture edge %d",
354 instance->assert);
355 return (0);
356 }
357 instance->pps_params.mode |= PPS_TSFMT_TSPEC;
358 if (time_pps_setparams(instance->pps_handle, &instance->pps_params) < 0) {
359 msyslog(LOG_ERR,
360 "refclock_jupiter: time_pps_setparams failed: %m");
361 return (0);
362 }
363 if (instance->hardpps) {
364 if (time_pps_kcbind(instance->pps_handle, PPS_KC_HARDPPS,
365 instance->pps_params.mode & ~PPS_TSFMT_TSPEC,
366 PPS_TSFMT_TSPEC) < 0) {
367 msyslog(LOG_ERR,
368 "refclock_jupiter: time_pps_kcbind failed: %m");
369 return (0);
370 }
371 hardpps_enable = 1;
372 }
373 /* instance->peer->precision = PPS_PRECISION; */
374
375 #if DEBUG
376 if (debug) {
377 time_pps_getparams(instance->pps_handle, &instance->pps_params);
378 jupiter_debug(instance->peer, __func__,
379 "pps capability 0x%x version %d mode 0x%x kern %d",
380 capability, instance->pps_params.api_version,
381 instance->pps_params.mode, instance->hardpps);
382 }
383 #endif
384
385 return (1);
386 }
387
388 /*
389 * Get PPSAPI timestamps.
390 *
391 * Return 0 on failure and 1 on success.
392 */
393 static int
jupiter_pps(struct instance * instance)394 jupiter_pps(struct instance *instance)
395 {
396 pps_info_t pps_info;
397 struct timespec timeout, ts;
398 double dtemp;
399 l_fp tstmp;
400
401 /*
402 * Convert the timespec nanoseconds field to ntp l_fp units.
403 */
404 if (instance->pps_handle == 0)
405 return 1;
406 timeout.tv_sec = 0;
407 timeout.tv_nsec = 0;
408 memcpy(&pps_info, &instance->pps_info, sizeof(pps_info_t));
409 if (time_pps_fetch(instance->pps_handle, PPS_TSFMT_TSPEC, &instance->pps_info,
410 &timeout) < 0)
411 return 1;
412 if (instance->pps_params.mode & PPS_CAPTUREASSERT) {
413 if (pps_info.assert_sequence ==
414 instance->pps_info.assert_sequence)
415 return 1;
416 ts = instance->pps_info.assert_timestamp;
417 } else if (instance->pps_params.mode & PPS_CAPTURECLEAR) {
418 if (pps_info.clear_sequence ==
419 instance->pps_info.clear_sequence)
420 return 1;
421 ts = instance->pps_info.clear_timestamp;
422 } else {
423 return 1;
424 }
425 if ((instance->ts.tv_sec == ts.tv_sec) && (instance->ts.tv_nsec == ts.tv_nsec))
426 return 1;
427 instance->ts = ts;
428
429 tstmp.l_ui = (u_int32)ts.tv_sec + JAN_1970;
430 dtemp = ts.tv_nsec * FRAC / 1e9;
431 tstmp.l_uf = (u_int32)dtemp;
432 instance->peer->procptr->lastrec = tstmp;
433 return 0;
434 }
435 #endif /* HAVE_PPSAPI */
436
437 /*
438 * jupiter_poll - jupiter watchdog routine
439 */
440 static void
jupiter_poll(int unit,struct peer * peer)441 jupiter_poll(int unit, struct peer *peer)
442 {
443 struct instance *instance;
444 struct refclockproc *pp;
445
446 pp = peer->procptr;
447 instance = pp->unitptr;
448
449 /*
450 * You don't need to poll this clock. It puts out timecodes
451 * once per second. If asked for a timestamp, take note.
452 * The next time a timecode comes in, it will be fed back.
453 */
454
455 /*
456 * If we haven't had a response in a while, reset the receiver.
457 */
458 if (instance->pollcnt > 0) {
459 instance->pollcnt--;
460 } else {
461 refclock_report(peer, CEVNT_TIMEOUT);
462
463 /* Request the receiver id to trigger a reconfig */
464 jupiter_reqonemsg(instance, JUPITER_O_ID);
465 instance->wantid = 0;
466 }
467
468 /*
469 * polled every 64 seconds. Ask jupiter_receive to hand in
470 * a timestamp.
471 */
472 instance->polled = 1;
473 pp->polls++;
474 }
475
476 /*
477 * jupiter_control - fudge control
478 */
479 static void
jupiter_control(int unit,const struct refclockstat * in,struct refclockstat * out,struct peer * peer)480 jupiter_control(
481 int unit, /* unit (not used) */
482 const struct refclockstat *in, /* input parameters (not used) */
483 struct refclockstat *out, /* output parameters (not used) */
484 struct peer *peer /* peer structure pointer */
485 )
486 {
487 struct refclockproc *pp;
488 struct instance *instance;
489 u_char sloppyclockflag;
490
491 pp = peer->procptr;
492 instance = pp->unitptr;
493
494 DTOLFP(pp->fudgetime2, &instance->limit);
495 /* Force positive value. */
496 if (L_ISNEG(&instance->limit))
497 L_NEG(&instance->limit);
498
499 #ifdef HAVE_PPSAPI
500 instance->assert = !(pp->sloppyclockflag & CLK_FLAG3);
501 jupiter_ppsapi(instance);
502 #endif /* HAVE_PPSAPI */
503
504 sloppyclockflag = instance->sloppyclockflag;
505 instance->sloppyclockflag = pp->sloppyclockflag;
506 if ((instance->sloppyclockflag & CLK_FLAG2) !=
507 (sloppyclockflag & CLK_FLAG2)) {
508 jupiter_debug(peer, __func__,
509 "mode switch: reset receiver");
510 jupiter_config(instance);
511 return;
512 }
513 }
514
515 /*
516 * jupiter_receive - receive gps data
517 * Gag me!
518 */
519 static void
jupiter_receive(struct recvbuf * rbufp)520 jupiter_receive(struct recvbuf *rbufp)
521 {
522 size_t bpcnt;
523 int cc, size, ppsret;
524 time_t last_timecode;
525 u_int32 laststime;
526 const char *cp;
527 u_char *bp;
528 u_short *sp;
529 struct jid *ip;
530 struct jheader *hp;
531 struct peer *peer;
532 struct refclockproc *pp;
533 struct instance *instance;
534 l_fp tstamp;
535
536 /* Initialize pointers and read the timecode and timestamp */
537 peer = rbufp->recv_peer;
538 pp = peer->procptr;
539 instance = pp->unitptr;
540
541 bp = (u_char *)rbufp->recv_buffer;
542 bpcnt = rbufp->recv_length;
543
544 /* This shouldn't happen */
545 if (bpcnt > sizeof(instance->sbuf) - instance->ssize)
546 bpcnt = sizeof(instance->sbuf) - instance->ssize;
547
548 /* Append to input buffer */
549 memcpy((u_char *)instance->sbuf + instance->ssize, bp, bpcnt);
550 instance->ssize += bpcnt;
551
552 /* While there's at least a header and we parse an intact message */
553 while (instance->ssize > (int)sizeof(*hp) && (cc = jupiter_recv(instance)) > 0) {
554 instance->pollcnt = 2;
555
556 tstamp = rbufp->recv_time;
557 hp = (struct jheader *)instance->sbuf;
558 sp = (u_short *)(hp + 1);
559 size = cc - sizeof(*hp);
560 switch (getshort(hp->id)) {
561
562 case JUPITER_O_PULSE:
563 if (size != sizeof(struct jpulse)) {
564 jupiter_debug(peer, __func__,
565 "pulse: len %d != %u",
566 size, (int)sizeof(struct jpulse));
567 refclock_report(peer, CEVNT_BADREPLY);
568 break;
569 }
570
571 /*
572 * There appears to be a firmware bug related
573 * to the pulse message; in addition to the one
574 * per second messages, we get an extra pulse
575 * message once an hour (on the anniversary of
576 * the cold start). It seems to come 200 ms
577 * after the one requested. So if we've seen a
578 * pulse message in the last 210 ms, we skip
579 * this one.
580 */
581 laststime = instance->stime;
582 instance->stime = DS2UI(((struct jpulse *)sp)->stime);
583 if (laststime != 0 && instance->stime - laststime <= 21) {
584 jupiter_debug(peer, __func__,
585 "avoided firmware bug (stime %.2f, laststime %.2f)",
586 (double)instance->stime * 0.01, (double)laststime * 0.01);
587 break;
588 }
589
590 /* Retrieve pps timestamp */
591 ppsret = jupiter_pps(instance);
592
593 /*
594 * Add one second if msg received early
595 * (i.e. before limit, a.k.a. fudgetime2) in
596 * the second.
597 */
598 L_SUB(&tstamp, &pp->lastrec);
599 if (!L_ISGEQ(&tstamp, &instance->limit))
600 ++pp->lastrec.l_ui;
601
602 /* Parse timecode (even when there's no pps) */
603 last_timecode = instance->timecode;
604 if ((cp = jupiter_parse_t(instance, sp)) != NULL) {
605 jupiter_debug(peer, __func__,
606 "pulse: %s", cp);
607 break;
608 }
609
610 /* Bail if we didn't get a pps timestamp */
611 if (ppsret)
612 break;
613
614 /* Bail if we don't have the last timecode yet */
615 if (last_timecode == 0)
616 break;
617
618 /* Add the new sample to a median filter */
619 tstamp.l_ui = JAN_1970 + (u_int32)last_timecode;
620 tstamp.l_uf = 0;
621
622 refclock_process_offset(pp, tstamp, pp->lastrec, pp->fudgetime1);
623
624 /*
625 * The clock will blurt a timecode every second
626 * but we only want one when polled. If we
627 * havn't been polled, bail out.
628 */
629 if (!instance->polled)
630 break;
631 instance->polled = 0;
632
633 /*
634 * It's a live one! Remember this time.
635 */
636
637 pp->lastref = pp->lastrec;
638 refclock_receive(peer);
639
640 /*
641 * If we get here - what we got from the clock is
642 * OK, so say so
643 */
644 refclock_report(peer, CEVNT_NOMINAL);
645
646 /*
647 * We have succeeded in answering the poll.
648 * Turn off the flag and return
649 */
650 instance->polled = 0;
651 break;
652
653 case JUPITER_O_GPOS:
654 if (size != sizeof(struct jgpos)) {
655 jupiter_debug(peer, __func__,
656 "gpos: len %d != %u",
657 size, (int)sizeof(struct jgpos));
658 refclock_report(peer, CEVNT_BADREPLY);
659 break;
660 }
661
662 if ((cp = jupiter_parse_gpos(instance, sp)) != NULL) {
663 jupiter_debug(peer, __func__,
664 "gpos: %s", cp);
665 break;
666 }
667 break;
668
669 case JUPITER_O_ID:
670 if (size != sizeof(struct jid)) {
671 jupiter_debug(peer, __func__,
672 "id: len %d != %u",
673 size, (int)sizeof(struct jid));
674 refclock_report(peer, CEVNT_BADREPLY);
675 break;
676 }
677 /*
678 * If we got this message because the Jupiter
679 * just powered instance, it needs to be reconfigured.
680 */
681 ip = (struct jid *)sp;
682 jupiter_debug(peer, __func__,
683 "%s chan ver %s, %s (%s)",
684 ip->chans, ip->vers, ip->date, ip->opts);
685 msyslog(LOG_DEBUG,
686 "jupiter_receive: %s chan ver %s, %s (%s)",
687 ip->chans, ip->vers, ip->date, ip->opts);
688 if (instance->wantid)
689 instance->wantid = 0;
690 else {
691 jupiter_debug(peer, __func__, "reset receiver");
692 jupiter_config(instance);
693 /*
694 * Restore since jupiter_config() just
695 * zeroed it
696 */
697 instance->ssize = cc;
698 }
699 break;
700
701 default:
702 jupiter_debug(peer, __func__, "unknown message id %d",
703 getshort(hp->id));
704 break;
705 }
706 instance->ssize -= cc;
707 if (instance->ssize < 0) {
708 fprintf(stderr, "jupiter_recv: negative ssize!\n");
709 abort();
710 } else if (instance->ssize > 0)
711 memcpy(instance->sbuf, (u_char *)instance->sbuf + cc, instance->ssize);
712 }
713 }
714
715 static const char *
jupiter_parse_t(struct instance * instance,u_short * sp)716 jupiter_parse_t(struct instance *instance, u_short *sp)
717 {
718 struct tm *tm;
719 char *cp;
720 struct jpulse *jp;
721 u_int32 sweek;
722 time_t last_timecode;
723 u_short flags;
724
725 jp = (struct jpulse *)sp;
726
727 /* The timecode is presented as seconds into the current GPS week */
728 sweek = DS2UI(jp->sweek) % WEEKSECS;
729
730 /*
731 * If we don't know the current GPS week, calculate it from the
732 * current time. (It's too bad they didn't include this
733 * important value in the pulse message). We'd like to pick it
734 * up from one of the other messages like gpos or chan but they
735 * don't appear to be synchronous with time keeping and changes
736 * too soon (something like 10 seconds before the new GPS
737 * week).
738 *
739 * If we already know the current GPS week, increment it when
740 * we wrap into a new week.
741 */
742 if (instance->gweek == 0) {
743 if (!instance->gpos_gweek) {
744 return ("jupiter_parse_t: Unknown gweek");
745 }
746
747 instance->gweek = instance->gpos_gweek;
748
749 /*
750 * Fix warps. GPOS has GPS time and PULSE has UTC.
751 * Plus, GPOS need not be completely in synch with
752 * the PPS signal.
753 */
754 if (instance->gpos_sweek >= sweek) {
755 if ((instance->gpos_sweek - sweek) > WEEKSECS / 2)
756 ++instance->gweek;
757 }
758 else {
759 if ((sweek - instance->gpos_sweek) > WEEKSECS / 2)
760 --instance->gweek;
761 }
762 }
763 else if (sweek == 0 && instance->lastsweek == WEEKSECS - 1) {
764 ++instance->gweek;
765 jupiter_debug(instance->peer, __func__,
766 "NEW gps week %u", instance->gweek);
767 }
768
769 /*
770 * See if the sweek stayed the same (this happens when there is
771 * no pps pulse).
772 *
773 * Otherwise, look for time warps:
774 *
775 * - we have stored at least one lastsweek and
776 * - the sweek didn't increase by one and
777 * - we didn't wrap to a new GPS week
778 *
779 * Then we warped.
780 */
781 if (instance->lastsweek == sweek)
782 jupiter_debug(instance->peer, __func__,
783 "gps sweek not incrementing (%d)",
784 sweek);
785 else if (instance->lastsweek != 2 * WEEKSECS &&
786 instance->lastsweek + 1 != sweek &&
787 !(sweek == 0 && instance->lastsweek == WEEKSECS - 1))
788 jupiter_debug(instance->peer, __func__,
789 "gps sweek jumped (was %d, now %d)",
790 instance->lastsweek, sweek);
791 instance->lastsweek = sweek;
792
793 /* This timecode describes next pulse */
794 last_timecode = instance->timecode;
795 instance->timecode =
796 GPS_EPOCH + (instance->gweek * WEEKSECS) + sweek;
797
798 if (last_timecode == 0)
799 /* XXX debugging */
800 jupiter_debug(instance->peer, __func__,
801 "UTC <none> (gweek/sweek %u/%u)",
802 instance->gweek, sweek);
803 else {
804 /* XXX debugging */
805 tm = gmtime(&last_timecode);
806 cp = asctime(tm);
807
808 jupiter_debug(instance->peer, __func__,
809 "UTC %.24s (gweek/sweek %u/%u)",
810 cp, instance->gweek, sweek);
811
812 /* Billboard last_timecode (which is now the current time) */
813 instance->peer->procptr->year = tm->tm_year + 1900;
814 instance->peer->procptr->day = tm->tm_yday + 1;
815 instance->peer->procptr->hour = tm->tm_hour;
816 instance->peer->procptr->minute = tm->tm_min;
817 instance->peer->procptr->second = tm->tm_sec;
818 }
819
820 flags = getshort(jp->flags);
821
822 /* Toss if not designated "valid" by the gps */
823 if ((flags & JUPITER_O_PULSE_VALID) == 0) {
824 refclock_report(instance->peer, CEVNT_BADTIME);
825 return ("time mark not valid");
826 }
827
828 /* We better be sync'ed to UTC... */
829 if ((flags & JUPITER_O_PULSE_UTC) == 0) {
830 refclock_report(instance->peer, CEVNT_BADTIME);
831 return ("time mark not sync'ed to UTC");
832 }
833
834 return (NULL);
835 }
836
837 static const char *
jupiter_parse_gpos(struct instance * instance,u_short * sp)838 jupiter_parse_gpos(struct instance *instance, u_short *sp)
839 {
840 struct jgpos *jg;
841 time_t t;
842 struct tm *tm;
843 char *cp;
844
845 jg = (struct jgpos *)sp;
846
847 if (jg->navval != 0) {
848 /*
849 * Solution not valid. Use caution and refuse
850 * to determine GPS week from this message.
851 */
852 instance->gpos_gweek = 0;
853 instance->gpos_sweek = 0;
854 return ("Navigation solution not valid");
855 }
856
857 instance->gpos_sweek = DS2UI(jg->sweek);
858 instance->gpos_gweek = get_full_week(get_base_week(),
859 getshort(jg->gweek));
860
861 /* according to the protocol spec, the seconds-in-week cannot
862 * exceed the nominal value: Is it really necessary to normalise
863 * the seconds???
864 */
865 while(instance->gpos_sweek >= WEEKSECS) {
866 instance->gpos_sweek -= WEEKSECS;
867 ++instance->gpos_gweek;
868 }
869 instance->gweek = 0;
870
871 t = GPS_EPOCH + (instance->gpos_gweek * WEEKSECS) + instance->gpos_sweek;
872 tm = gmtime(&t);
873 cp = asctime(tm);
874
875 jupiter_debug(instance->peer, __func__,
876 "GPS %.24s (gweek/sweek %u/%u)",
877 cp, instance->gpos_gweek, instance->gpos_sweek);
878 return (NULL);
879 }
880
881 /*
882 * jupiter_debug - print debug messages
883 */
884 static void
jupiter_debug(struct peer * peer,const char * function,const char * fmt,...)885 jupiter_debug(
886 struct peer * peer,
887 const char * function,
888 const char * fmt,
889 ...
890 )
891 {
892 char buffer[200];
893 va_list ap;
894
895 va_start(ap, fmt);
896 /*
897 * Print debug message to stdout
898 * In the future, we may want to get get more creative...
899 */
900 mvsnprintf(buffer, sizeof(buffer), fmt, ap);
901 record_clock_stats(&peer->srcadr, buffer);
902 #ifdef DEBUG
903 if (debug) {
904 printf("%s: %s\n", function, buffer);
905 fflush(stdout);
906 }
907 #endif
908
909 va_end(ap);
910 }
911
912 /* Checksum and transmit a message to the Jupiter */
913 static char *
jupiter_send(struct instance * instance,struct jheader * hp)914 jupiter_send(struct instance *instance, struct jheader *hp)
915 {
916 u_int len, size;
917 ssize_t cc;
918 u_short *sp;
919 static char errstr[132];
920
921 size = sizeof(*hp);
922 hp->hsum = putshort(jupiter_cksum((u_short *)hp,
923 (size / sizeof(u_short)) - 1));
924 len = getshort(hp->len);
925 if (len > 0) {
926 sp = (u_short *)(hp + 1);
927 sp[len] = putshort(jupiter_cksum(sp, len));
928 size += (len + 1) * sizeof(u_short);
929 }
930
931 if ((cc = write(instance->peer->procptr->io.fd, (char *)hp, size)) < 0) {
932 msnprintf(errstr, sizeof(errstr), "write: %m");
933 return (errstr);
934 } else if (cc != (int)size) {
935 snprintf(errstr, sizeof(errstr), "short write (%zd != %u)", cc, size);
936 return (errstr);
937 }
938 return (NULL);
939 }
940
941 /* Request periodic message output */
942 static struct {
943 struct jheader jheader;
944 struct jrequest jrequest;
945 } reqmsg = {
946 { putshort(JUPITER_SYNC), 0,
947 putshort((sizeof(struct jrequest) / sizeof(u_short)) - 1),
948 0, JUPITER_FLAG_REQUEST | JUPITER_FLAG_NAK |
949 JUPITER_FLAG_CONN | JUPITER_FLAG_LOG, 0 },
950 { 0, 0, 0, 0 }
951 };
952
953 /* An interval of zero means to output on trigger */
954 static void
jupiter_reqmsg(struct instance * instance,u_int id,u_int interval)955 jupiter_reqmsg(struct instance *instance, u_int id,
956 u_int interval)
957 {
958 struct jheader *hp;
959 struct jrequest *rp;
960 char *cp;
961
962 hp = &reqmsg.jheader;
963 hp->id = putshort(id);
964 rp = &reqmsg.jrequest;
965 rp->trigger = putshort(interval == 0);
966 rp->interval = putshort(interval);
967 if ((cp = jupiter_send(instance, hp)) != NULL)
968 jupiter_debug(instance->peer, __func__, "%u: %s", id, cp);
969 }
970
971 /* Cancel periodic message output */
972 static struct jheader canmsg = {
973 putshort(JUPITER_SYNC), 0, 0, 0,
974 JUPITER_FLAG_REQUEST | JUPITER_FLAG_NAK | JUPITER_FLAG_DISC,
975 0
976 };
977
978 static void
jupiter_canmsg(struct instance * instance,u_int id)979 jupiter_canmsg(struct instance *instance, u_int id)
980 {
981 struct jheader *hp;
982 char *cp;
983
984 hp = &canmsg;
985 hp->id = putshort(id);
986 if ((cp = jupiter_send(instance, hp)) != NULL)
987 jupiter_debug(instance->peer, __func__, "%u: %s", id, cp);
988 }
989
990 /* Request a single message output */
991 static struct jheader reqonemsg = {
992 putshort(JUPITER_SYNC), 0, 0, 0,
993 JUPITER_FLAG_REQUEST | JUPITER_FLAG_NAK | JUPITER_FLAG_QUERY,
994 0
995 };
996
997 static void
jupiter_reqonemsg(struct instance * instance,u_int id)998 jupiter_reqonemsg(struct instance *instance, u_int id)
999 {
1000 struct jheader *hp;
1001 char *cp;
1002
1003 hp = &reqonemsg;
1004 hp->id = putshort(id);
1005 if ((cp = jupiter_send(instance, hp)) != NULL)
1006 jupiter_debug(instance->peer, __func__, "%u: %s", id, cp);
1007 }
1008
1009 /* Set the platform dynamics */
1010 static struct {
1011 struct jheader jheader;
1012 struct jplat jplat;
1013 } platmsg = {
1014 { putshort(JUPITER_SYNC), putshort(JUPITER_I_PLAT),
1015 putshort((sizeof(struct jplat) / sizeof(u_short)) - 1), 0,
1016 JUPITER_FLAG_REQUEST | JUPITER_FLAG_NAK, 0 },
1017 { 0, 0, 0 }
1018 };
1019
1020 static void
jupiter_platform(struct instance * instance,u_int platform)1021 jupiter_platform(struct instance *instance, u_int platform)
1022 {
1023 struct jheader *hp;
1024 struct jplat *pp;
1025 char *cp;
1026
1027 hp = &platmsg.jheader;
1028 pp = &platmsg.jplat;
1029 pp->platform = putshort(platform);
1030 if ((cp = jupiter_send(instance, hp)) != NULL)
1031 jupiter_debug(instance->peer, __func__, "%u: %s", platform, cp);
1032 }
1033
1034 /* Checksum "len" shorts */
1035 static u_short
jupiter_cksum(u_short * sp,u_int len)1036 jupiter_cksum(u_short *sp, u_int len)
1037 {
1038 u_short sum, x;
1039
1040 sum = 0;
1041 while (len-- > 0) {
1042 x = *sp++;
1043 sum += getshort(x);
1044 }
1045 return (~sum + 1);
1046 }
1047
1048 /* Return the size of the next message (or zero if we don't have it all yet) */
1049 static int
jupiter_recv(struct instance * instance)1050 jupiter_recv(struct instance *instance)
1051 {
1052 int n, len, size, cc;
1053 struct jheader *hp;
1054 u_char *bp;
1055 u_short *sp;
1056
1057 /* Must have at least a header's worth */
1058 cc = sizeof(*hp);
1059 size = instance->ssize;
1060 if (size < cc)
1061 return (0);
1062
1063 /* Search for the sync short if missing */
1064 sp = instance->sbuf;
1065 hp = (struct jheader *)sp;
1066 if (getshort(hp->sync) != JUPITER_SYNC) {
1067 /* Wasn't at the front, sync up */
1068 jupiter_debug(instance->peer, __func__, "syncing");
1069 bp = (u_char *)sp;
1070 n = size;
1071 while (n >= 2) {
1072 if (bp[0] != (JUPITER_SYNC & 0xff)) {
1073 /*
1074 jupiter_debug(instance->peer, __func__,
1075 "{0x%x}", bp[0]);
1076 */
1077 ++bp;
1078 --n;
1079 continue;
1080 }
1081 if (bp[1] == ((JUPITER_SYNC >> 8) & 0xff))
1082 break;
1083 /*
1084 jupiter_debug(instance->peer, __func__,
1085 "{0x%x 0x%x}", bp[0], bp[1]);
1086 */
1087 bp += 2;
1088 n -= 2;
1089 }
1090 /*
1091 jupiter_debug(instance->peer, __func__, "\n");
1092 */
1093 /* Shuffle data to front of input buffer */
1094 if (n > 0)
1095 memcpy(sp, bp, n);
1096 size = n;
1097 instance->ssize = size;
1098 if (size < cc || hp->sync != JUPITER_SYNC)
1099 return (0);
1100 }
1101
1102 if (jupiter_cksum(sp, (cc / sizeof(u_short) - 1)) !=
1103 getshort(hp->hsum)) {
1104 jupiter_debug(instance->peer, __func__, "bad header checksum!");
1105 /* This is drastic but checksum errors should be rare */
1106 instance->ssize = 0;
1107 return (0);
1108 }
1109
1110 /* Check for a payload */
1111 len = getshort(hp->len);
1112 if (len > 0) {
1113 n = (len + 1) * sizeof(u_short);
1114 /* Not enough data yet */
1115 if (size < cc + n)
1116 return (0);
1117
1118 /* Check payload checksum */
1119 sp = (u_short *)(hp + 1);
1120 if (jupiter_cksum(sp, len) != getshort(sp[len])) {
1121 jupiter_debug(instance->peer,
1122 __func__, "bad payload checksum!");
1123 /* This is drastic but checksum errors should be rare */
1124 instance->ssize = 0;
1125 return (0);
1126 }
1127 cc += n;
1128 }
1129 return (cc);
1130 }
1131
1132 static u_int
get_base_week(void)1133 get_base_week(void)
1134 {
1135 static int init_done /* = 0 */;
1136 static u_int base_week;
1137
1138 /* Get the build date, convert to days since GPS epoch and
1139 * finally weeks since GPS epoch. Note that the build stamp is
1140 * trusted once it is fetched -- only dates before the GPS epoch
1141 * are not permitted. This will permit proper synchronisation
1142 * for a time range of 1024 weeks starting with 00:00:00 of the
1143 * last Sunday on or before the build time.
1144 *
1145 * If the impossible happens and fetching the build date fails,
1146 * a 1024-week cycle starting with 2016-01-03 is assumed to
1147 * avoid catastropic errors. This will work until 2035-08-19.
1148 */
1149 if (!init_done) {
1150 struct calendar bd;
1151 if (ntpcal_get_build_date(&bd)) {
1152 int32_t days = ntpcal_date_to_rd(&bd);
1153 if (days > RDN_GPS_EPOCH)
1154 days -= RDN_GPS_EPOCH;
1155 else
1156 days = 0;
1157 base_week = days / 7;
1158 } else {
1159 base_week = 1878; /* 2016-01-03, Sunday */
1160 msyslog(LOG_ERR,
1161 "refclock_jupiter: ntpcal_get_build_date() failed: %s",
1162 "using 2016-01-03 as GPS base!");
1163 }
1164 init_done = 1;
1165 }
1166 return base_week;
1167 }
1168
1169 static u_int
get_full_week(u_int base_week,u_int gpos_week)1170 get_full_week(
1171 u_int base_week,
1172 u_int gpos_week
1173 )
1174 {
1175 /* Periodic extension on base week. Since the period is 1024
1176 * weeks and we do unsigned arithmetic here, we can do wonderful
1177 * things with masks and the well-defined overflow behaviour.
1178 */
1179 return base_week + ((gpos_week - base_week) & 1023);
1180 }
1181
1182 #else /* not (REFCLOCK && CLOCK_JUPITER && HAVE_PPSAPI) */
1183 int refclock_jupiter_bs;
1184 #endif /* not (REFCLOCK && CLOCK_JUPITER && HAVE_PPSAPI) */
1185