1 /*******************************************************************************
2 *
3 * Module : refclock_tsyncpci.c
4 * Date : 09/08/08
5 * Purpose : Implements a reference clock driver for the NTP daemon. This
6 * reference clock driver provides a means to communicate with
7 * the Spectracom TSYNC PCI timing devices and use them as a time
8 * source.
9 *
10 * (C) Copyright 2008 Spectracom Corporation
11 *
12 * This software is provided by Spectracom Corporation 'as is' and
13 * any express or implied warranties, including, but not limited to, the
14 * implied warranties of merchantability and fitness for a particular purpose
15 * are disclaimed. In no event shall Spectracom Corporation be liable
16 * for any direct, indirect, incidental, special, exemplary, or consequential
17 * damages (including, but not limited to, procurement of substitute goods
18 * or services; loss of use, data, or profits; or business interruption)
19 * however caused and on any theory of liability, whether in contract, strict
20 * liability, or tort (including negligence or otherwise) arising in any way
21 * out of the use of this software, even if advised of the possibility of
22 * such damage.
23 *
24 * This software is released for distribution according to the NTP copyright
25 * and license contained in html/copyright.html of NTP source.
26 *
27 *******************************************************************************/
28 #ifdef HAVE_CONFIG_H
29 #include <config.h>
30 #endif
31
32 #if defined(REFCLOCK) && defined(CLOCK_TSYNCPCI)
33
34 #include <asm/ioctl.h>
35 #ifdef HAVE_SYS_IOCTL_H
36 # include <sys/ioctl.h>
37 #endif
38
39 #include <stdio.h>
40 #include <ctype.h>
41 #include <netinet/in.h>
42
43
44 #include "ntpd.h"
45 #include "ntp_io.h"
46 #include "ntp_refclock.h"
47 #include "ntp_unixtime.h"
48 #include "ntp_stdlib.h"
49 #include "ntp_calendar.h"
50
51
52 /*******************************************************************************
53 **
54 ** This driver supports the Spectracom TSYNC PCI GPS receiver. It requires
55 ** that the tsyncpci.o device driver be installed and loaded.
56 **
57 *******************************************************************************/
58
59 #define TSYNC_PCI_REVISION "1.11"
60
61 /*
62 ** TPRO interface definitions
63 */
64 #define DEVICE "/dev/tsyncpci" /* device name */
65 #define PRECISION (-20) /* precision assumed (1 us) */
66 #define DESCRIPTION "Spectracom TSYNC-PCI" /* WRU */
67
68 #define SECONDS_1900_TO_1970 (2208988800U)
69
70 #define TSYNC_REF_IID (0x2500) // SS CAI, REF IID
71 #define TSYNC_REF_DEST_ID (0x0001) // KTS Firmware
72 #define TSYNC_REF_IN_PYLD_OFF (0)
73 #define TSYNC_REF_IN_LEN (0)
74 #define TSYNC_REF_OUT_PYLD_OFF (0)
75 #define TSYNC_REF_OUT_LEN (8)
76 #define TSYNC_REF_MAX_OUT_LEN (16)
77 #define TSYNC_REF_PYLD_LEN (TSYNC_REF_IN_LEN + \
78 TSYNC_REF_MAX_OUT_LEN)
79 #define TSYNC_REF_LEN (4)
80 #define TSYNC_REF_LOCAL ("LOCL")
81
82 #define TSYNC_TMSCL_IID (0x2301) // CS CAI, TIMESCALE IID
83 #define TSYNC_TMSCL_DEST_ID (0x0001) // KTS Firmware
84 #define TSYNC_TMSCL_IN_PYLD_OFF (0)
85 #define TSYNC_TMSCL_IN_LEN (0)
86 #define TSYNC_TMSCL_OUT_PYLD_OFF (0)
87 #define TSYNC_TMSCL_OUT_LEN (4)
88 #define TSYNC_TMSCL_MAX_OUT_LEN (12)
89 #define TSYNC_TMSCL_PYLD_LEN (TSYNC_TMSCL_IN_LEN + \
90 TSYNC_TMSCL_MAX_OUT_LEN)
91
92 #define TSYNC_LEAP_IID (0x2307) // CS CAI, LEAP SEC IID
93 #define TSYNC_LEAP_DEST_ID (0x0001) // KTS Firmware
94 #define TSYNC_LEAP_IN_PYLD_OFF (0)
95 #define TSYNC_LEAP_IN_LEN (0)
96 #define TSYNC_LEAP_OUT_PYLD_OFF (0)
97 #define TSYNC_LEAP_OUT_LEN (28)
98 #define TSYNC_LEAP_MAX_OUT_LEN (36)
99 #define TSYNC_LEAP_PYLD_LEN (TSYNC_LEAP_IN_LEN + \
100 TSYNC_LEAP_MAX_OUT_LEN)
101
102 // These define the base date/time of the system clock. The system time will
103 // be tracked as the number of seconds from this date/time.
104 #define TSYNC_TIME_BASE_YEAR (1970) // earliest acceptable year
105
106 #define TSYNC_LCL_STRATUM (0)
107
108 /*
109 ** TSYNC Time Scales type
110 */
111 typedef enum
112 {
113 TIME_SCALE_UTC = 0, // Universal Coordinated Time
114 TIME_SCALE_TAI = 1, // International Atomic Time
115 TIME_SCALE_GPS = 2, // Global Positioning System
116 TIME_SCALE_LOCAL = 3, // UTC w/local rules for time zone and DST
117 NUM_TIME_SCALES = 4, // Number of time scales
118
119 TIME_SCALE_MAX = 15 // Maximum number of timescales
120
121 } TIME_SCALE;
122
123 /*
124 ** TSYNC Board Object
125 */
126 typedef struct BoardObj {
127
128 int file_descriptor;
129 unsigned short devid;
130 unsigned short options;
131 unsigned char firmware[5];
132 unsigned char FPGA[5];
133 unsigned char driver[7];
134
135 } BoardObj;
136
137 /*
138 ** TSYNC Time Object
139 */
140 typedef struct TimeObj {
141
142 unsigned char syncOption; /* -M option */
143 unsigned int secsDouble; /* seconds floating pt */
144 unsigned char seconds; /* seconds whole num */
145 unsigned char minutes;
146 unsigned char hours;
147 unsigned short days;
148 unsigned short year;
149 unsigned short flags; /* bit 2 SYNC, bit 1 TCODE; all others 0 */
150
151 } TimeObj;
152
153 /*
154 ** NTP Time Object
155 */
156 typedef struct NtpTimeObj {
157
158 TimeObj timeObj;
159 struct timeval tv;
160 unsigned int refId;
161
162 } NtpTimeObj;
163 /*
164 ** TSYNC Supervisor Reference Object
165 */
166 typedef struct ReferenceObj {
167
168 char time[TSYNC_REF_LEN];
169 char pps[TSYNC_REF_LEN];
170
171 } ReferenceObj;
172
173 /*
174 ** TSYNC Seconds Time Object
175 */
176 typedef struct SecTimeObj
177 {
178 unsigned int seconds;
179 unsigned int ns;
180 }
181 SecTimeObj;
182
183 /*
184 ** TSYNC DOY Time Object
185 */
186 typedef struct DoyTimeObj
187 {
188 unsigned int year;
189 unsigned int doy;
190 unsigned int hour;
191 unsigned int minute;
192 unsigned int second;
193 unsigned int ns;
194 }
195 DoyTimeObj;
196
197 /*
198 ** TSYNC Leap Second Object
199 */
200 typedef struct LeapSecondObj
201 {
202 int offset;
203 DoyTimeObj utcDate;
204 }
205 LeapSecondObj;
206
207 /*
208 * structures for ioctl interactions with driver
209 */
210 #define DI_PAYLOADS_STARTER_LENGTH 4
211 typedef struct ioctl_trans_di {
212
213 // input parameters
214 uint16_t dest;
215 uint16_t iid;
216
217 uint32_t inPayloadOffset;
218 uint32_t inLength;
219 uint32_t outPayloadOffset;
220 uint32_t maxOutLength;
221
222 // output parameters
223 uint32_t actualOutLength;
224 int32_t status;
225
226 // Input and output
227
228 // The payloads field MUST be last in ioctl_trans_di.
229 uint8_t payloads[DI_PAYLOADS_STARTER_LENGTH];
230
231 }ioctl_trans_di;
232
233 /*
234 * structure for looking up a reference ID from a reference name
235 */
236 typedef struct
237 {
238 const char* pRef; // KTS Reference Name
239 const char* pRefId; // NTP Reference ID
240
241 } RefIdLookup;
242
243 /*
244 * unit control structure
245 */
246 typedef struct {
247 uint32_t refPrefer; // Reference prefer flag
248 uint32_t refId; // Host peer reference ID
249 uint8_t refStratum; // Host peer reference stratum
250
251 } TsyncUnit;
252
253 /*
254 ** Function prototypes
255 */
256 static void tsync_poll (int unit, struct peer *);
257 static void tsync_shutdown (int, struct peer *);
258 static int tsync_start (int, struct peer *);
259
260 /*
261 ** Helper functions
262 */
263 static void ApplyTimeOffset (DoyTimeObj* pDt, int off);
264 static void SecTimeFromDoyTime (SecTimeObj* pSt, DoyTimeObj* pDt);
265 static void DoyTimeFromSecTime (DoyTimeObj* pDt, SecTimeObj* pSt);
266
267 /*
268 ** Transfer vector
269 */
270 struct refclock refclock_tsyncpci = {
271 tsync_start, /* start up driver */
272 tsync_shutdown, /* shut down driver */
273 tsync_poll, /* transmit poll message */
274 noentry, /* not used (old tsync_control) */
275 noentry, /* initialize driver (not used) */
276 noentry, /* not used (old tsync_buginfo) */
277 NOFLAGS /* not used */
278 };
279
280 /*
281 * Reference ID lookup table
282 */
283 static RefIdLookup RefIdLookupTbl[] =
284 {
285 {"gps", "GPS"},
286 {"ir", "IRIG"},
287 {"hvq", "HVQ"},
288 {"frq", "FREQ"},
289 {"mdm", "ACTS"},
290 {"epp", "PPS"},
291 {"ptp", "PTP"},
292 {"asc", "ATC"},
293 {"hst0", "USER"},
294 {"hst", TSYNC_REF_LOCAL},
295 {"self", TSYNC_REF_LOCAL},
296 {NULL, NULL}
297 };
298
299 /*******************************************************************************
300 ** IOCTL DEFINITIONS
301 *******************************************************************************/
302 #define IOCTL_TPRO_ID 't'
303 #define IOCTL_TPRO_OPEN _IOWR(IOCTL_TPRO_ID, 0, BoardObj)
304 #define IOCTL_TPRO_GET_NTP_TIME _IOWR(IOCTL_TPRO_ID, 25, NtpTimeObj)
305 #define IOCTL_TSYNC_GET _IOWR(IOCTL_TPRO_ID, 26, ioctl_trans_di)
306
307 /******************************************************************************
308 *
309 * Function: tsync_start()
310 * Description: Used to intialize the Spectracom TSYNC reference driver.
311 *
312 * Parameters:
313 * IN: unit - not used.
314 * *peer - pointer to this reference clock's peer structure
315 * Returns: 0 - unsuccessful
316 * 1 - successful
317 *
318 *******************************************************************************/
tsync_start(int unit,struct peer * peer)319 static int tsync_start(int unit, struct peer *peer)
320 {
321 struct refclockproc *pp;
322 TsyncUnit *up;
323
324
325 /*
326 ** initialize reference clock and peer parameters
327 */
328 pp = peer->procptr;
329 pp->clockdesc = DESCRIPTION;
330 pp->io.clock_recv = noentry;
331 pp->io.srcclock = peer;
332 pp->io.datalen = 0;
333 peer->precision = PRECISION;
334
335 // Allocate and initialize unit structure
336 if (!(up = (TsyncUnit*)emalloc(sizeof(TsyncUnit))))
337 {
338 return (0);
339 }
340
341 // Store reference preference
342 up->refPrefer = peer->flags & FLAG_PREFER;
343
344 // Initialize reference stratum level and ID
345 up->refStratum = STRATUM_UNSPEC;
346 strncpy((char *)&up->refId, TSYNC_REF_LOCAL, TSYNC_REF_LEN);
347
348 // Attach unit structure
349 pp->unitptr = (caddr_t)up;
350
351 /* Declare our refId as local in the beginning because we do not know
352 * what our actual refid is yet.
353 */
354 strncpy((char *)&pp->refid, TSYNC_REF_LOCAL, TSYNC_REF_LEN);
355
356 return (1);
357
358 } /* End - tsync_start() */
359
360 /*******************************************************************************
361 **
362 ** Function: tsync_shutdown()
363 ** Description: Handles anything related to shutting down the reference clock
364 ** driver. Nothing at this point in time.
365 **
366 ** Parameters:
367 ** IN: unit - not used.
368 ** *peer - pointer to this reference clock's peer structure
369 ** Returns: none.
370 **
371 *******************************************************************************/
tsync_shutdown(int unit,struct peer * peer)372 static void tsync_shutdown(int unit, struct peer *peer)
373 {
374
375 } /* End - tsync_shutdown() */
376
377 /******************************************************************************
378 *
379 * Function: tsync_poll()
380 * Description: Retrieve time from the TSYNC device.
381 *
382 * Parameters:
383 * IN: unit - not used.
384 * *peer - pointer to this reference clock's peer structure
385 * Returns: none.
386 *
387 *******************************************************************************/
tsync_poll(int unit,struct peer * peer)388 static void tsync_poll(int unit, struct peer *peer)
389 {
390 char device[32];
391 struct refclockproc *pp;
392 struct calendar jt;
393 TsyncUnit *up;
394 unsigned char synch;
395 double seconds;
396 int err;
397 int err1;
398 int err2;
399 int err3;
400 int i;
401 int j;
402 unsigned int itAllocationLength;
403 unsigned int itAllocationLength1;
404 unsigned int itAllocationLength2;
405 NtpTimeObj TimeContext;
406 BoardObj hBoard;
407 char timeRef[TSYNC_REF_LEN + 1];
408 char ppsRef [TSYNC_REF_LEN + 1];
409 TIME_SCALE tmscl = TIME_SCALE_UTC;
410 LeapSecondObj leapSec;
411 ioctl_trans_di *it;
412 ioctl_trans_di *it1;
413 ioctl_trans_di *it2;
414 l_fp offset;
415 l_fp ltemp;
416 ReferenceObj * pRefObj;
417
418
419 /* Construct the device name */
420 sprintf(device, "%s%d", DEVICE, (int)peer->refclkunit);
421
422 printf("Polling device number %d...\n", (int)peer->refclkunit);
423
424 /* Open the TSYNC device */
425 hBoard.file_descriptor = open(device, O_RDONLY | O_NDELAY, 0777);
426
427 /* If error opening TSYNC device... */
428 if (hBoard.file_descriptor < 0)
429 {
430 msyslog(LOG_ERR, "Couldn't open device");
431 return;
432 }
433
434 /* If error while initializing the board... */
435 if (ioctl(hBoard.file_descriptor, IOCTL_TPRO_OPEN, &hBoard) < 0)
436 {
437 msyslog(LOG_ERR, "Couldn't initialize device");
438 close(hBoard.file_descriptor);
439 return;
440 }
441
442 /* Allocate memory for ioctl message */
443 itAllocationLength =
444 (sizeof(ioctl_trans_di) - DI_PAYLOADS_STARTER_LENGTH) +
445 TSYNC_REF_IN_LEN + TSYNC_REF_MAX_OUT_LEN;
446
447 it = (ioctl_trans_di*)alloca(itAllocationLength);
448 if (it == NULL) {
449 msyslog(LOG_ERR, "Couldn't allocate transaction memory - Reference");
450 return;
451 }
452
453 /* Build SS_GetRef ioctl message */
454 it->dest = TSYNC_REF_DEST_ID;
455 it->iid = TSYNC_REF_IID;
456 it->inPayloadOffset = TSYNC_REF_IN_PYLD_OFF;
457 it->inLength = TSYNC_REF_IN_LEN;
458 it->outPayloadOffset = TSYNC_REF_OUT_PYLD_OFF;
459 it->maxOutLength = TSYNC_REF_MAX_OUT_LEN;
460 it->actualOutLength = 0;
461 it->status = 0;
462 memset(it->payloads, 0, TSYNC_REF_MAX_OUT_LEN);
463
464 /* Read the reference from the TSYNC-PCI device */
465 err = ioctl(hBoard.file_descriptor,
466 IOCTL_TSYNC_GET,
467 (char *)it);
468
469 /* Allocate memory for ioctl message */
470 itAllocationLength1 =
471 (sizeof(ioctl_trans_di) - DI_PAYLOADS_STARTER_LENGTH) +
472 TSYNC_TMSCL_IN_LEN + TSYNC_TMSCL_MAX_OUT_LEN;
473
474 it1 = (ioctl_trans_di*)alloca(itAllocationLength1);
475 if (it1 == NULL) {
476 msyslog(LOG_ERR, "Couldn't allocate transaction memory - Time Scale");
477 return;
478 }
479
480 /* Build CS_GetTimeScale ioctl message */
481 it1->dest = TSYNC_TMSCL_DEST_ID;
482 it1->iid = TSYNC_TMSCL_IID;
483 it1->inPayloadOffset = TSYNC_TMSCL_IN_PYLD_OFF;
484 it1->inLength = TSYNC_TMSCL_IN_LEN;
485 it1->outPayloadOffset = TSYNC_TMSCL_OUT_PYLD_OFF;
486 it1->maxOutLength = TSYNC_TMSCL_MAX_OUT_LEN;
487 it1->actualOutLength = 0;
488 it1->status = 0;
489 memset(it1->payloads, 0, TSYNC_TMSCL_MAX_OUT_LEN);
490
491 /* Read the Time Scale info from the TSYNC-PCI device */
492 err1 = ioctl(hBoard.file_descriptor,
493 IOCTL_TSYNC_GET,
494 (char *)it1);
495
496 /* Allocate memory for ioctl message */
497 itAllocationLength2 =
498 (sizeof(ioctl_trans_di) - DI_PAYLOADS_STARTER_LENGTH) +
499 TSYNC_LEAP_IN_LEN + TSYNC_LEAP_MAX_OUT_LEN;
500
501 it2 = (ioctl_trans_di*)alloca(itAllocationLength2);
502 if (it2 == NULL) {
503 msyslog(LOG_ERR, "Couldn't allocate transaction memory - Leap Second");
504 return;
505 }
506
507 /* Build CS_GetLeapSec ioctl message */
508 it2->dest = TSYNC_LEAP_DEST_ID;
509 it2->iid = TSYNC_LEAP_IID;
510 it2->inPayloadOffset = TSYNC_LEAP_IN_PYLD_OFF;
511 it2->inLength = TSYNC_LEAP_IN_LEN;
512 it2->outPayloadOffset = TSYNC_LEAP_OUT_PYLD_OFF;
513 it2->maxOutLength = TSYNC_LEAP_MAX_OUT_LEN;
514 it2->actualOutLength = 0;
515 it2->status = 0;
516 memset(it2->payloads, 0, TSYNC_LEAP_MAX_OUT_LEN);
517
518 /* Read the leap seconds info from the TSYNC-PCI device */
519 err2 = ioctl(hBoard.file_descriptor,
520 IOCTL_TSYNC_GET,
521 (char *)it2);
522
523 pp = peer->procptr;
524 up = (TsyncUnit*)pp->unitptr;
525
526 /* Read the time from the TSYNC-PCI device */
527 err3 = ioctl(hBoard.file_descriptor,
528 IOCTL_TPRO_GET_NTP_TIME,
529 (char *)&TimeContext);
530
531 /* Close the TSYNC device */
532 close(hBoard.file_descriptor);
533
534 // Check for errors
535 if ((err < 0) ||(err1 < 0) || (err2 < 0) || (err3 < 0) ||
536 (it->status != 0) || (it1->status != 0) || (it2->status != 0) ||
537 (it->actualOutLength != TSYNC_REF_OUT_LEN) ||
538 (it1->actualOutLength != TSYNC_TMSCL_OUT_LEN) ||
539 (it2->actualOutLength != TSYNC_LEAP_OUT_LEN)) {
540 refclock_report(peer, CEVNT_FAULT);
541 return;
542 }
543
544 // Extract reference identifiers from ioctl payload
545 memset(timeRef, '\0', sizeof(timeRef));
546 memset(ppsRef, '\0', sizeof(ppsRef));
547 pRefObj = (void *)it->payloads;
548 memcpy(timeRef, pRefObj->time, TSYNC_REF_LEN);
549 memcpy(ppsRef, pRefObj->pps, TSYNC_REF_LEN);
550
551 // Extract the Clock Service Time Scale and convert to correct byte order
552 memcpy(&tmscl, it1->payloads, sizeof(tmscl));
553 tmscl = ntohl(tmscl);
554
555 // Extract leap second info from ioctl payload and perform byte swapping
556 for (i = 0; i < (sizeof(leapSec) / 4); i++)
557 {
558 for (j = 0; j < 4; j++)
559 {
560 ((unsigned char*)&leapSec)[(i * 4) + j] =
561 ((unsigned char*)(it2->payloads))[(i * 4) + (3 - j)];
562 }
563 }
564
565 // Determine time reference ID from reference name
566 for (i = 0; RefIdLookupTbl[i].pRef != NULL; i++)
567 {
568 // Search RefID table
569 if (strstr(timeRef, RefIdLookupTbl[i].pRef) != NULL)
570 {
571 // Found the matching string
572 break;
573 }
574 }
575
576 // Determine pps reference ID from reference name
577 for (j = 0; RefIdLookupTbl[j].pRef != NULL; j++)
578 {
579 // Search RefID table
580 if (strstr(ppsRef, RefIdLookupTbl[j].pRef) != NULL)
581 {
582 // Found the matching string
583 break;
584 }
585 }
586
587 // Determine synchronization state from flags
588 synch = (TimeContext.timeObj.flags == 0x4) ? 1 : 0;
589
590 // Pull seconds information from time object
591 seconds = (double) (TimeContext.timeObj.secsDouble);
592 seconds /= (double) 1000000.0;
593
594 /*
595 ** Convert the number of microseconds to double and then place in the
596 ** peer's last received long floating point format.
597 */
598 DTOLFP(((double)TimeContext.tv.tv_usec / 1000000.0), &pp->lastrec);
599
600 /*
601 ** The specTimeStamp is the number of seconds since 1/1/1970, while the
602 ** peer's lastrec time should be compatible with NTP which is seconds since
603 ** 1/1/1900. So Add the number of seconds between 1900 and 1970 to the
604 ** specTimeStamp and place in the peer's lastrec long floating point struct.
605 */
606 pp->lastrec.Ul_i.Xl_ui += (unsigned int)TimeContext.tv.tv_sec +
607 SECONDS_1900_TO_1970;
608
609 pp->polls++;
610
611 /*
612 ** set the reference clock object
613 */
614 sprintf(pp->a_lastcode, "%03d %02d:%02d:%02.6f",
615 TimeContext.timeObj.days, TimeContext.timeObj.hours,
616 TimeContext.timeObj.minutes, seconds);
617
618 pp->lencode = strlen (pp->a_lastcode);
619 pp->day = TimeContext.timeObj.days;
620 pp->hour = TimeContext.timeObj.hours;
621 pp->minute = TimeContext.timeObj.minutes;
622 pp->second = (int) seconds;
623 seconds = (seconds - (double) (pp->second / 1.0)) * 1000000000;
624 pp->nsec = (long) seconds;
625
626 /*
627 ** calculate year start
628 */
629 jt.year = TimeContext.timeObj.year;
630 jt.yearday = 1;
631 jt.monthday = 1;
632 jt.month = 1;
633 jt.hour = 0;
634 jt.minute = 0;
635 jt.second = 0;
636 pp->yearstart = caltontp(&jt);
637
638 // Calculate and report reference clock offset
639 offset.l_ui = (long)(((pp->day - 1) * 24) + pp->hour + GMT);
640 offset.l_ui = (offset.l_ui * 60) + (long)pp->minute;
641 offset.l_ui = (offset.l_ui * 60) + (long)pp->second;
642 offset.l_ui = offset.l_ui + (long)pp->yearstart;
643 offset.l_uf = 0;
644 DTOLFP(pp->nsec / 1e9, <emp);
645 L_ADD(&offset, <emp);
646 refclock_process_offset(pp, offset, pp->lastrec,
647 pp->fudgetime1);
648
649 // KTS in sync
650 if (synch) {
651 // Subtract leap second info by one second to determine effective day
652 ApplyTimeOffset(&(leapSec.utcDate), -1);
653
654 // If there is a leap second today and the KTS is using a time scale
655 // which handles leap seconds then
656 if ((tmscl != TIME_SCALE_GPS) && (tmscl != TIME_SCALE_TAI) &&
657 (leapSec.utcDate.year == (unsigned int)TimeContext.timeObj.year) &&
658 (leapSec.utcDate.doy == (unsigned int)TimeContext.timeObj.days))
659 {
660 // If adding a second
661 if (leapSec.offset == 1)
662 {
663 pp->leap = LEAP_ADDSECOND;
664 }
665 // Else if removing a second
666 else if (leapSec.offset == -1)
667 {
668 pp->leap = LEAP_DELSECOND;
669 }
670 // Else report no leap second pending (no handling of offsets
671 // other than +1 or -1)
672 else
673 {
674 pp->leap = LEAP_NOWARNING;
675 }
676 }
677 // Else report no leap second pending
678 else
679 {
680 pp->leap = LEAP_NOWARNING;
681 }
682
683 peer->leap = pp->leap;
684 refclock_report(peer, CEVNT_NOMINAL);
685
686 // If reference name reported, then not in holdover
687 if ((RefIdLookupTbl[i].pRef != NULL) &&
688 (RefIdLookupTbl[j].pRef != NULL))
689 {
690 // Determine if KTS being synchronized by host (identified as
691 // "LOCL")
692 if ((strcmp(RefIdLookupTbl[i].pRefId, TSYNC_REF_LOCAL) == 0) ||
693 (strcmp(RefIdLookupTbl[j].pRefId, TSYNC_REF_LOCAL) == 0))
694 {
695 // Clear prefer flag
696 peer->flags &= ~FLAG_PREFER;
697
698 // Set reference clock stratum level as unusable
699 pp->stratum = STRATUM_UNSPEC;
700 peer->stratum = pp->stratum;
701
702 // If a valid peer is available
703 if ((sys_peer != NULL) && (sys_peer != peer))
704 {
705 // Store reference peer stratum level and ID
706 up->refStratum = sys_peer->stratum;
707 up->refId = addr2refid(&sys_peer->srcadr);
708 }
709 }
710 else
711 {
712 // Restore prefer flag
713 peer->flags |= up->refPrefer;
714
715 // Store reference stratum as local clock
716 up->refStratum = TSYNC_LCL_STRATUM;
717 strncpy((char *)&up->refId, RefIdLookupTbl[j].pRefId,
718 TSYNC_REF_LEN);
719
720 // Set reference clock stratum level as local clock
721 pp->stratum = TSYNC_LCL_STRATUM;
722 peer->stratum = pp->stratum;
723 }
724
725 // Update reference name
726 strncpy((char *)&pp->refid, RefIdLookupTbl[j].pRefId,
727 TSYNC_REF_LEN);
728 peer->refid = pp->refid;
729 }
730 // Else in holdover
731 else
732 {
733 // Restore prefer flag
734 peer->flags |= up->refPrefer;
735
736 // Update reference ID to saved ID
737 pp->refid = up->refId;
738 peer->refid = pp->refid;
739
740 // Update stratum level to saved stratum level
741 pp->stratum = up->refStratum;
742 peer->stratum = pp->stratum;
743 }
744 }
745 // Else KTS not in sync
746 else {
747 // Place local identifier in peer RefID
748 strncpy((char *)&pp->refid, TSYNC_REF_LOCAL, TSYNC_REF_LEN);
749 peer->refid = pp->refid;
750
751 // Report not in sync
752 pp->leap = LEAP_NOTINSYNC;
753 peer->leap = pp->leap;
754 }
755
756 if (pp->coderecv == pp->codeproc) {
757 refclock_report(peer, CEVNT_TIMEOUT);
758 return;
759 }
760
761 record_clock_stats(&peer->srcadr, pp->a_lastcode);
762 refclock_receive(peer);
763
764 /* Increment the number of times the reference has been polled */
765 pp->polls++;
766
767 } /* End - tsync_poll() */
768
769
770 ////////////////////////////////////////////////////////////////////////////////
771 // Function: ApplyTimeOffset
772 // Description: The ApplyTimeOffset function adds an offset (in seconds) to a
773 // specified date and time. The specified date and time is passed
774 // back after being modified.
775 //
776 // Assumptions: 1. Every fourth year is a leap year. Therefore, this function
777 // is only accurate through Feb 28, 2100.
778 ////////////////////////////////////////////////////////////////////////////////
ApplyTimeOffset(DoyTimeObj * pDt,int off)779 void ApplyTimeOffset(DoyTimeObj* pDt, int off)
780 {
781 SecTimeObj st; // Time, in seconds
782
783
784 // Convert date and time to seconds
785 SecTimeFromDoyTime(&st, pDt);
786
787 // Apply offset
788 st.seconds = (int)((signed long long)st.seconds + (signed long long)off);
789
790 // Convert seconds to date and time
791 DoyTimeFromSecTime(pDt, &st);
792
793 } // End ApplyTimeOffset
794
795
796 ////////////////////////////////////////////////////////////////////////////////
797 // Function: SecTimeFromDoyTime
798 // Description: The SecTimeFromDoyTime function converts a specified date
799 // and time into a count of seconds since the base time. This
800 // function operates across the range Base Time to Max Time for
801 // the system.
802 //
803 // Assumptions: 1. A leap year is any year evenly divisible by 4. Therefore,
804 // this function is only accurate through Feb 28, 2100.
805 // 2. Conversion does not account for leap seconds.
806 ////////////////////////////////////////////////////////////////////////////////
SecTimeFromDoyTime(SecTimeObj * pSt,DoyTimeObj * pDt)807 void SecTimeFromDoyTime(SecTimeObj* pSt, DoyTimeObj* pDt)
808 {
809 unsigned int yrs; // Years
810 unsigned int lyrs; // Leap years
811
812
813 // Start with accumulated time of 0
814 pSt->seconds = 0;
815
816 // Calculate the number of years and leap years
817 yrs = pDt->year - TSYNC_TIME_BASE_YEAR;
818 lyrs = (yrs + 1) / 4;
819
820 // Convert leap years and years
821 pSt->seconds += lyrs * SECSPERLEAPYEAR;
822 pSt->seconds += (yrs - lyrs) * SECSPERYEAR;
823
824 // Convert days, hours, minutes and seconds
825 pSt->seconds += (pDt->doy - 1) * SECSPERDAY;
826 pSt->seconds += pDt->hour * SECSPERHR;
827 pSt->seconds += pDt->minute * SECSPERMIN;
828 pSt->seconds += pDt->second;
829
830 // Copy the subseconds count
831 pSt->ns = pDt->ns;
832
833 } // End SecTimeFromDoyTime
834
835
836 ////////////////////////////////////////////////////////////////////////////////
837 // Function: DoyTimeFromSecTime
838 // Description: The DoyTimeFromSecTime function converts a specified count
839 // of seconds since the start of our base time into a SecTimeObj
840 // structure.
841 //
842 // Assumptions: 1. A leap year is any year evenly divisible by 4. Therefore,
843 // this function is only accurate through Feb 28, 2100.
844 // 2. Conversion does not account for leap seconds.
845 ////////////////////////////////////////////////////////////////////////////////
DoyTimeFromSecTime(DoyTimeObj * pDt,SecTimeObj * pSt)846 void DoyTimeFromSecTime(DoyTimeObj* pDt, SecTimeObj* pSt)
847 {
848 signed long long secs; // Seconds accumulator variable
849 unsigned int yrs; // Years accumulator variable
850 unsigned int doys; // Days accumulator variable
851 unsigned int hrs; // Hours accumulator variable
852 unsigned int mins; // Minutes accumulator variable
853
854
855 // Convert the seconds count into a signed 64-bit number for calculations
856 secs = (signed long long)(pSt->seconds);
857
858 // Calculate the number of 4 year chunks
859 yrs = (unsigned int)((secs /
860 ((SECSPERYEAR * 3) + SECSPERLEAPYEAR)) * 4);
861 secs %= ((SECSPERYEAR * 3) + SECSPERLEAPYEAR);
862
863 // If there is at least a normal year worth of time left
864 if (secs >= SECSPERYEAR)
865 {
866 // Increment the number of years and subtract a normal year of time
867 yrs++;
868 secs -= SECSPERYEAR;
869 }
870
871 // If there is still at least a normal year worth of time left
872 if (secs >= SECSPERYEAR)
873 {
874 // Increment the number of years and subtract a normal year of time
875 yrs++;
876 secs -= SECSPERYEAR;
877 }
878
879 // If there is still at least a leap year worth of time left
880 if (secs >= SECSPERLEAPYEAR)
881 {
882 // Increment the number of years and subtract a leap year of time
883 yrs++;
884 secs -= SECSPERLEAPYEAR;
885 }
886
887 // Calculate the day of year as the number of days left, then add 1
888 // because months start on the 1st.
889 doys = (unsigned int)((secs / SECSPERDAY) + 1);
890 secs %= SECSPERDAY;
891
892 // Calculate the hour
893 hrs = (unsigned int)(secs / SECSPERHR);
894 secs %= SECSPERHR;
895
896 // Calculate the minute
897 mins = (unsigned int)(secs / SECSPERMIN);
898 secs %= SECSPERMIN;
899
900 // Fill in the doytime structure
901 pDt->year = yrs + TSYNC_TIME_BASE_YEAR;
902 pDt->doy = doys;
903 pDt->hour = hrs;
904 pDt->minute = mins;
905 pDt->second = (unsigned int)secs;
906 pDt->ns = pSt->ns;
907
908 } // End DoyTimeFromSecTime
909
910 #else
911 NONEMPTY_TRANSLATION_UNIT
912 #endif /* REFCLOCK */
913