![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to refclock_parse.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / ntpd|
Return to refclock_parse.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / ntpd |
1.1 misho 1: /*
2: * /src/NTP/REPOSITORY/ntp4-dev/ntpd/refclock_parse.c,v 4.81 2009/05/01 10:15:29 kardel RELEASE_20090105_A
3: *
4: * refclock_parse.c,v 4.81 2009/05/01 10:15:29 kardel RELEASE_20090105_A
5: *
6: * generic reference clock driver for several DCF/GPS/MSF/... receivers
7: *
8: * PPS notes:
9: * On systems that support PPSAPI (RFC2783) PPSAPI is the
10: * preferred interface.
11: *
12: * Optionally make use of a STREAMS module for input processing where
13: * available and configured. This STREAMS module reduces the time
14: * stamp latency for serial and PPS events.
15: * Currently the STREAMS module is only available for Suns running
16: * SunOS 4.x and SunOS5.x.
17: *
18: * Copyright (c) 1995-2009 by Frank Kardel <kardel <AT> ntp.org>
19: * Copyright (c) 1989-1994 by Frank Kardel, Friedrich-Alexander Universität Erlangen-Nürnberg, Germany
20: *
21: * Redistribution and use in source and binary forms, with or without
22: * modification, are permitted provided that the following conditions
23: * are met:
24: * 1. Redistributions of source code must retain the above copyright
25: * notice, this list of conditions and the following disclaimer.
26: * 2. Redistributions in binary form must reproduce the above copyright
27: * notice, this list of conditions and the following disclaimer in the
28: * documentation and/or other materials provided with the distribution.
29: * 3. Neither the name of the author nor the names of its contributors
30: * may be used to endorse or promote products derived from this software
31: * without specific prior written permission.
32: *
33: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
34: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
35: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
36: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
37: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
38: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
39: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
40: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
41: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
42: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
43: * SUCH DAMAGE.
44: *
45: */
46:
47: #ifdef HAVE_CONFIG_H
48: # include "config.h"
49: #endif
50:
51: #if defined(REFCLOCK) && defined(CLOCK_PARSE)
52:
53: /*
54: * This driver currently provides the support for
55: * - Meinberg receiver DCF77 PZF 535 (TCXO version) (DCF)
56: * - Meinberg receiver DCF77 PZF 535 (OCXO version) (DCF)
57: * - Meinberg receiver DCF77 PZF 509 (DCF)
58: * - Meinberg receiver DCF77 AM receivers (e.g. C51) (DCF)
59: * - IGEL CLOCK (DCF)
60: * - ELV DCF7000 (DCF)
61: * - Schmid clock (DCF)
62: * - Conrad DCF77 receiver module (DCF)
63: * - FAU DCF77 NTP receiver (TimeBrick) (DCF)
64: * - WHARTON 400A Series clock (DCF)
65: *
66: * - Meinberg GPS166/GPS167 (GPS)
67: * - Trimble (TSIP and TAIP protocol) (GPS)
68: *
69: * - RCC8000 MSF Receiver (MSF)
70: * - VARITEXT clock (MSF)
71: */
72:
73: /*
74: * Meinberg receivers are usually connected via a
75: * 9600 baud serial line
76: *
77: * The Meinberg GPS receivers also have a special NTP time stamp
78: * format. The firmware release is Uni-Erlangen.
79: *
80: * Meinberg generic receiver setup:
81: * output time code every second
82: * Baud rate 9600 7E2S
83: *
84: * Meinberg GPS16x setup:
85: * output time code every second
86: * Baudrate 19200 8N1
87: *
88: * This software supports the standard data formats used
89: * in Meinberg receivers.
90: *
91: * Special software versions are only sensible for the
92: * GPS 16x family of receivers.
93: *
94: * Meinberg can be reached via: http://www.meinberg.de/
95: */
96:
97: #include "ntpd.h"
98: #include "ntp_refclock.h"
99: #include "ntp_unixtime.h" /* includes <sys/time.h> */
100: #include "ntp_control.h"
101: #include "ntp_string.h"
102:
103: #include <stdio.h>
104: #include <ctype.h>
105: #ifndef TM_IN_SYS_TIME
106: # include <time.h>
107: #endif
108:
109: #ifdef HAVE_UNISTD_H
110: # include <unistd.h>
111: #endif
112:
113: #if !defined(STREAM) && !defined(HAVE_SYSV_TTYS) && !defined(HAVE_BSD_TTYS) && !defined(HAVE_TERMIOS)
114: # include "Bletch: Define one of {STREAM,HAVE_SYSV_TTYS,HAVE_TERMIOS}"
115: #endif
116:
117: #ifdef STREAM
118: # include <sys/stream.h>
119: # include <sys/stropts.h>
120: #endif
121:
122: #ifdef HAVE_TERMIOS
123: # define TTY_GETATTR(_FD_, _ARG_) tcgetattr((_FD_), (_ARG_))
124: # define TTY_SETATTR(_FD_, _ARG_) tcsetattr((_FD_), TCSANOW, (_ARG_))
125: # undef HAVE_SYSV_TTYS
126: #endif
127:
128: #ifdef HAVE_SYSV_TTYS
129: # define TTY_GETATTR(_FD_, _ARG_) ioctl((_FD_), TCGETA, (_ARG_))
130: # define TTY_SETATTR(_FD_, _ARG_) ioctl((_FD_), TCSETAW, (_ARG_))
131: #endif
132:
133: #ifdef HAVE_BSD_TTYS
134: /* #error CURRENTLY NO BSD TTY SUPPORT */
135: # include "Bletch: BSD TTY not currently supported"
136: #endif
137:
138: #ifdef HAVE_SYS_IOCTL_H
139: # include <sys/ioctl.h>
140: #endif
141:
142: #ifdef HAVE_PPSAPI
143: # include "ppsapi_timepps.h"
144: # include "refclock_atom.h"
145: #endif
146:
147: #ifdef PPS
148: # ifdef HAVE_SYS_PPSCLOCK_H
149: # include <sys/ppsclock.h>
150: # endif
151: # ifdef HAVE_TIO_SERIAL_STUFF
152: # include <linux/serial.h>
153: # endif
154: #endif
155:
156: #define BUFFER_SIZE(_BUF, _PTR) ((_BUF) + sizeof(_BUF) - (_PTR))
157: #define BUFFER_SIZES(_BUF, _PTR, _SZ) ((_BUF) + (_SZ) - (_PTR))
158:
159: /*
160: * document type of PPS interfacing - copy of ifdef mechanism in local_input()
161: */
162: #undef PPS_METHOD
163:
164: #ifdef HAVE_PPSAPI
165: #define PPS_METHOD "PPS API"
166: #else
167: #ifdef TIOCDCDTIMESTAMP
168: #define PPS_METHOD "TIOCDCDTIMESTAMP"
169: #else /* TIOCDCDTIMESTAMP */
170: #if defined(HAVE_STRUCT_PPSCLOCKEV) && (defined(HAVE_CIOGETEV) || defined(HAVE_TIOCGPPSEV))
171: #ifdef HAVE_CIOGETEV
172: #define PPS_METHOD "CIOGETEV"
173: #endif
174: #ifdef HAVE_TIOCGPPSEV
175: #define PPS_METHOD "TIOCGPPSEV"
176: #endif
177: #endif
178: #endif /* TIOCDCDTIMESTAMP */
179: #endif /* HAVE_PPSAPI */
180:
181: #include "ntp_io.h"
182: #include "ntp_stdlib.h"
183:
184: #include "parse.h"
185: #include "mbg_gps166.h"
186: #include "trimble.h"
187: #include "binio.h"
188: #include "ascii.h"
189: #include "ieee754io.h"
190: #include "recvbuff.h"
191:
192: static char rcsid[] = "refclock_parse.c,v 4.81 2009/05/01 10:15:29 kardel RELEASE_20090105_A+POWERUPTRUST";
193:
194: /**===========================================================================
195: ** external interface to ntp mechanism
196: **/
197:
198: static int parse_start (int, struct peer *);
199: static void parse_shutdown (int, struct peer *);
200: static void parse_poll (int, struct peer *);
201: static void parse_control (int, struct refclockstat *, struct refclockstat *, struct peer *);
202:
203: struct refclock refclock_parse = {
204: parse_start,
205: parse_shutdown,
206: parse_poll,
207: parse_control,
208: noentry,
209: noentry,
210: NOFLAGS
211: };
212:
213: /*
214: * Definitions
215: */
216: #define MAXUNITS 4 /* maximum number of "PARSE" units permitted */
217: #define PARSEDEVICE "/dev/refclock-%d" /* device to open %d is unit number */
218: #define PARSEPPSDEVICE "/dev/refclockpps-%d" /* optional pps device to open %d is unit number */
219:
220: #undef ABS
221: #define ABS(_X_) (((_X_) < 0) ? -(_X_) : (_X_))
222:
223: #define PARSE_HARDPPS_DISABLE 0
224: #define PARSE_HARDPPS_ENABLE 1
225:
226: /**===========================================================================
227: ** function vector for dynamically binding io handling mechanism
228: **/
229:
230: struct parseunit; /* to keep inquiring minds happy */
231:
232: typedef struct bind
233: {
234: const char *bd_description; /* name of type of binding */
235: int (*bd_init) (struct parseunit *); /* initialize */
236: void (*bd_end) (struct parseunit *); /* end */
237: int (*bd_setcs) (struct parseunit *, parsectl_t *); /* set character size */
238: int (*bd_disable) (struct parseunit *); /* disable */
239: int (*bd_enable) (struct parseunit *); /* enable */
240: int (*bd_getfmt) (struct parseunit *, parsectl_t *); /* get format */
241: int (*bd_setfmt) (struct parseunit *, parsectl_t *); /* setfmt */
242: int (*bd_timecode) (struct parseunit *, parsectl_t *); /* get time code */
243: void (*bd_receive) (struct recvbuf *); /* receive operation */
244: int (*bd_io_input) (struct recvbuf *); /* input operation */
245: } bind_t;
246:
247: #define PARSE_END(_X_) (*(_X_)->binding->bd_end)(_X_)
248: #define PARSE_SETCS(_X_, _CS_) (*(_X_)->binding->bd_setcs)(_X_, _CS_)
249: #define PARSE_ENABLE(_X_) (*(_X_)->binding->bd_enable)(_X_)
250: #define PARSE_DISABLE(_X_) (*(_X_)->binding->bd_disable)(_X_)
251: #define PARSE_GETFMT(_X_, _DCT_) (*(_X_)->binding->bd_getfmt)(_X_, _DCT_)
252: #define PARSE_SETFMT(_X_, _DCT_) (*(_X_)->binding->bd_setfmt)(_X_, _DCT_)
253: #define PARSE_GETTIMECODE(_X_, _DCT_) (*(_X_)->binding->bd_timecode)(_X_, _DCT_)
254:
255: /*
256: * special handling flags
257: */
258: #define PARSE_F_PPSONSECOND 0x00000001 /* PPS pulses are on second */
259: #define PARSE_F_POWERUPTRUST 0x00000100 /* POWERUP state ist trusted for */
260: /* trusttime after SYNC was seen */
261: /**===========================================================================
262: ** error message regression handling
263: **
264: ** there are quite a few errors that can occur in rapid succession such as
265: ** noisy input data or no data at all. in order to reduce the amount of
266: ** syslog messages in such case, we are using a backoff algorithm. We limit
267: ** the number of error messages of a certain class to 1 per time unit. if a
268: ** configurable number of messages is displayed that way, we move on to the
269: ** next time unit / count for that class. a count of messages that have been
270: ** suppressed is held and displayed whenever a corresponding message is
271: ** displayed. the time units for a message class will also be displayed.
272: ** whenever an error condition clears we reset the error message state,
273: ** thus we would still generate much output on pathological conditions
274: ** where the system oscillates between OK and NOT OK states. coping
275: ** with that condition is currently considered too complicated.
276: **/
277:
278: #define ERR_ALL (unsigned)~0 /* "all" errors */
279: #define ERR_BADDATA (unsigned)0 /* unusable input data/conversion errors */
280: #define ERR_NODATA (unsigned)1 /* no input data */
281: #define ERR_BADIO (unsigned)2 /* read/write/select errors */
282: #define ERR_BADSTATUS (unsigned)3 /* unsync states */
283: #define ERR_BADEVENT (unsigned)4 /* non nominal events */
284: #define ERR_INTERNAL (unsigned)5 /* internal error */
285: #define ERR_CNT (unsigned)(ERR_INTERNAL+1)
286:
287: #define ERR(_X_) if (list_err(parse, (_X_)))
288:
289: struct errorregression
290: {
291: u_long err_count; /* number of repititions per class */
292: u_long err_delay; /* minimum delay between messages */
293: };
294:
295: static struct errorregression
296: err_baddata[] = /* error messages for bad input data */
297: {
298: { 1, 0 }, /* output first message immediately */
299: { 5, 60 }, /* output next five messages in 60 second intervals */
300: { 3, 3600 }, /* output next 3 messages in hour intervals */
301: { 0, 12*3600 } /* repeat messages only every 12 hours */
302: };
303:
304: static struct errorregression
305: err_nodata[] = /* error messages for missing input data */
306: {
307: { 1, 0 }, /* output first message immediately */
308: { 5, 60 }, /* output next five messages in 60 second intervals */
309: { 3, 3600 }, /* output next 3 messages in hour intervals */
310: { 0, 12*3600 } /* repeat messages only every 12 hours */
311: };
312:
313: static struct errorregression
314: err_badstatus[] = /* unsynchronized state messages */
315: {
316: { 1, 0 }, /* output first message immediately */
317: { 5, 60 }, /* output next five messages in 60 second intervals */
318: { 3, 3600 }, /* output next 3 messages in hour intervals */
319: { 0, 12*3600 } /* repeat messages only every 12 hours */
320: };
321:
322: static struct errorregression
323: err_badio[] = /* io failures (bad reads, selects, ...) */
324: {
325: { 1, 0 }, /* output first message immediately */
326: { 5, 60 }, /* output next five messages in 60 second intervals */
327: { 5, 3600 }, /* output next 3 messages in hour intervals */
328: { 0, 12*3600 } /* repeat messages only every 12 hours */
329: };
330:
331: static struct errorregression
332: err_badevent[] = /* non nominal events */
333: {
334: { 20, 0 }, /* output first message immediately */
335: { 6, 60 }, /* output next five messages in 60 second intervals */
336: { 5, 3600 }, /* output next 3 messages in hour intervals */
337: { 0, 12*3600 } /* repeat messages only every 12 hours */
338: };
339:
340: static struct errorregression
341: err_internal[] = /* really bad things - basically coding/OS errors */
342: {
343: { 0, 0 }, /* output all messages immediately */
344: };
345:
346: static struct errorregression *
347: err_tbl[] =
348: {
349: err_baddata,
350: err_nodata,
351: err_badio,
352: err_badstatus,
353: err_badevent,
354: err_internal
355: };
356:
357: struct errorinfo
358: {
359: u_long err_started; /* begin time (ntp) of error condition */
360: u_long err_last; /* last time (ntp) error occurred */
361: u_long err_cnt; /* number of error repititions */
362: u_long err_suppressed; /* number of suppressed messages */
363: struct errorregression *err_stage; /* current error stage */
364: };
365:
366: /**===========================================================================
367: ** refclock instance data
368: **/
369:
370: struct parseunit
371: {
372: /*
373: * NTP management
374: */
375: struct peer *peer; /* backlink to peer structure - refclock inactive if 0 */
376: struct refclockproc *generic; /* backlink to refclockproc structure */
377:
378: /*
379: * PARSE io
380: */
381: bind_t *binding; /* io handling binding */
382:
383: /*
384: * parse state
385: */
386: parse_t parseio; /* io handling structure (user level parsing) */
387:
388: /*
389: * type specific parameters
390: */
391: struct parse_clockinfo *parse_type; /* link to clock description */
392:
393: /*
394: * clock state handling/reporting
395: */
396: u_char flags; /* flags (leap_control) */
397: u_long lastchange; /* time (ntp) when last state change accured */
398: u_long statetime[CEVNT_MAX+1]; /* accumulated time of clock states */
399: u_long pollneeddata; /* current_time(!=0) for receive sample expected in PPS mode */
400: u_short lastformat; /* last format used */
401: u_long lastsync; /* time (ntp) when clock was last seen fully synchronized */
402: u_long maxunsync; /* max time in seconds a receiver is trusted after loosing synchronisation */
403: double ppsphaseadjust; /* phase adjustment of PPS time stamp */
404: u_long lastmissed; /* time (ntp) when poll didn't get data (powerup heuristic) */
405: u_long ppsserial; /* magic cookie for ppsclock serials (avoids stale ppsclock data) */
406: int ppsfd; /* fd to ise for PPS io */
407: #ifdef HAVE_PPSAPI
408: int hardppsstate; /* current hard pps state */
409: struct refclock_atom atom; /* PPSAPI structure */
410: #endif
411: parsetime_t timedata; /* last (parse module) data */
412: void *localdata; /* optional local, receiver-specific data */
413: unsigned long localstate; /* private local state */
414: struct errorinfo errors[ERR_CNT]; /* error state table for suppressing excessive error messages */
415: struct ctl_var *kv; /* additional pseudo variables */
416: u_long laststatistic; /* time when staticstics where output */
417: };
418:
419:
420: /**===========================================================================
421: ** Clockinfo section all parameter for specific clock types
422: ** includes NTP parameters, TTY parameters and IO handling parameters
423: **/
424:
425: static void poll_dpoll (struct parseunit *);
426: static void poll_poll (struct peer *);
427: static int poll_init (struct parseunit *);
428:
429: typedef struct poll_info
430: {
431: u_long rate; /* poll rate - once every "rate" seconds - 0 off */
432: const char *string; /* string to send for polling */
433: u_long count; /* number of characters in string */
434: } poll_info_t;
435:
436: #define NO_CL_FLAGS 0
437: #define NO_POLL 0
438: #define NO_INIT 0
439: #define NO_END 0
440: #define NO_EVENT 0
441: #define NO_LCLDATA 0
442: #define NO_MESSAGE 0
443: #define NO_PPSDELAY 0
444:
445: #define DCF_ID "DCF" /* generic DCF */
446: #define DCF_A_ID "DCFa" /* AM demodulation */
447: #define DCF_P_ID "DCFp" /* psuedo random phase shift */
448: #define GPS_ID "GPS" /* GPS receiver */
449:
450: #define NOCLOCK_ROOTDELAY 0.0
451: #define NOCLOCK_BASEDELAY 0.0
452: #define NOCLOCK_DESCRIPTION 0
453: #define NOCLOCK_MAXUNSYNC 0
454: #define NOCLOCK_CFLAG 0
455: #define NOCLOCK_IFLAG 0
456: #define NOCLOCK_OFLAG 0
457: #define NOCLOCK_LFLAG 0
458: #define NOCLOCK_ID "TILT"
459: #define NOCLOCK_POLL NO_POLL
460: #define NOCLOCK_INIT NO_INIT
461: #define NOCLOCK_END NO_END
462: #define NOCLOCK_DATA NO_LCLDATA
463: #define NOCLOCK_FORMAT ""
464: #define NOCLOCK_TYPE CTL_SST_TS_UNSPEC
465: #define NOCLOCK_SAMPLES 0
466: #define NOCLOCK_KEEP 0
467:
468: #define DCF_TYPE CTL_SST_TS_LF
469: #define GPS_TYPE CTL_SST_TS_UHF
470:
471: /*
472: * receiver specific constants
473: */
474: #define MBG_SPEED (B9600)
475: #define MBG_CFLAG (CS7|PARENB|CREAD|CLOCAL|HUPCL|CSTOPB)
476: #define MBG_IFLAG (IGNBRK|IGNPAR|ISTRIP)
477: #define MBG_OFLAG 0
478: #define MBG_LFLAG 0
479: #define MBG_FLAGS PARSE_F_PPSONSECOND
480:
481: /*
482: * Meinberg DCF77 receivers
483: */
484: #define DCFUA31_ROOTDELAY 0.0 /* 0 */
485: #define DCFUA31_BASEDELAY 0.010 /* 10.7421875ms: 10 ms (+/- 3 ms) */
486: #define DCFUA31_DESCRIPTION "Meinberg DCF77 C51 or compatible"
487: #define DCFUA31_MAXUNSYNC 60*30 /* only trust clock for 1/2 hour */
488: #define DCFUA31_SPEED MBG_SPEED
489: #define DCFUA31_CFLAG MBG_CFLAG
490: #define DCFUA31_IFLAG MBG_IFLAG
491: #define DCFUA31_OFLAG MBG_OFLAG
492: #define DCFUA31_LFLAG MBG_LFLAG
493: #define DCFUA31_SAMPLES 5
494: #define DCFUA31_KEEP 3
495: #define DCFUA31_FORMAT "Meinberg Standard"
496:
497: /*
498: * Meinberg DCF PZF535/TCXO (FM/PZF) receiver
499: */
500: #define DCFPZF535_ROOTDELAY 0.0
501: #define DCFPZF535_BASEDELAY 0.001968 /* 1.968ms +- 104us (oscilloscope) - relative to start (end of STX) */
502: #define DCFPZF535_DESCRIPTION "Meinberg DCF PZF 535/509 / TCXO"
503: #define DCFPZF535_MAXUNSYNC 60*60*12 /* only trust clock for 12 hours
504: * @ 5e-8df/f we have accumulated
505: * at most 2.16 ms (thus we move to
506: * NTP synchronisation */
507: #define DCFPZF535_SPEED MBG_SPEED
508: #define DCFPZF535_CFLAG MBG_CFLAG
509: #define DCFPZF535_IFLAG MBG_IFLAG
510: #define DCFPZF535_OFLAG MBG_OFLAG
511: #define DCFPZF535_LFLAG MBG_LFLAG
512: #define DCFPZF535_SAMPLES 5
513: #define DCFPZF535_KEEP 3
514: #define DCFPZF535_FORMAT "Meinberg Standard"
515:
516: /*
517: * Meinberg DCF PZF535/OCXO receiver
518: */
519: #define DCFPZF535OCXO_ROOTDELAY 0.0
520: #define DCFPZF535OCXO_BASEDELAY 0.001968 /* 1.968ms +- 104us (oscilloscope) - relative to start (end of STX) */
521: #define DCFPZF535OCXO_DESCRIPTION "Meinberg DCF PZF 535/509 / OCXO"
522: #define DCFPZF535OCXO_MAXUNSYNC 60*60*96 /* only trust clock for 4 days
523: * @ 5e-9df/f we have accumulated
524: * at most an error of 1.73 ms
525: * (thus we move to NTP synchronisation) */
526: #define DCFPZF535OCXO_SPEED MBG_SPEED
527: #define DCFPZF535OCXO_CFLAG MBG_CFLAG
528: #define DCFPZF535OCXO_IFLAG MBG_IFLAG
529: #define DCFPZF535OCXO_OFLAG MBG_OFLAG
530: #define DCFPZF535OCXO_LFLAG MBG_LFLAG
531: #define DCFPZF535OCXO_SAMPLES 5
532: #define DCFPZF535OCXO_KEEP 3
533: #define DCFPZF535OCXO_FORMAT "Meinberg Standard"
534:
535: /*
536: * Meinberg GPS16X receiver
537: */
538: static void gps16x_message (struct parseunit *, parsetime_t *);
539: static int gps16x_poll_init (struct parseunit *);
540:
541: #define GPS16X_ROOTDELAY 0.0 /* nothing here */
542: #define GPS16X_BASEDELAY 0.001968 /* XXX to be fixed ! 1.968ms +- 104us (oscilloscope) - relative to start (end of STX) */
543: #define GPS16X_DESCRIPTION "Meinberg GPS16x receiver"
544: #define GPS16X_MAXUNSYNC 60*60*96 /* only trust clock for 4 days
545: * @ 5e-9df/f we have accumulated
546: * at most an error of 1.73 ms
547: * (thus we move to NTP synchronisation) */
548: #define GPS16X_SPEED B19200
549: #define GPS16X_CFLAG (CS8|CREAD|CLOCAL|HUPCL)
550: #define GPS16X_IFLAG (IGNBRK|IGNPAR)
551: #define GPS16X_OFLAG MBG_OFLAG
552: #define GPS16X_LFLAG MBG_LFLAG
553: #define GPS16X_POLLRATE 6
554: #define GPS16X_POLLCMD ""
555: #define GPS16X_CMDSIZE 0
556:
557: static poll_info_t gps16x_pollinfo = { GPS16X_POLLRATE, GPS16X_POLLCMD, GPS16X_CMDSIZE };
558:
559: #define GPS16X_INIT gps16x_poll_init
560: #define GPS16X_POLL 0
561: #define GPS16X_END 0
562: #define GPS16X_DATA ((void *)(&gps16x_pollinfo))
563: #define GPS16X_MESSAGE gps16x_message
564: #define GPS16X_ID GPS_ID
565: #define GPS16X_FORMAT "Meinberg GPS Extended"
566: #define GPS16X_SAMPLES 5
567: #define GPS16X_KEEP 3
568:
569: /*
570: * ELV DCF7000 Wallclock-Receiver/Switching Clock (Kit)
571: *
572: * This is really not the hottest clock - but before you have nothing ...
573: */
574: #define DCF7000_ROOTDELAY 0.0 /* 0 */
575: #define DCF7000_BASEDELAY 0.405 /* slow blow */
576: #define DCF7000_DESCRIPTION "ELV DCF7000"
577: #define DCF7000_MAXUNSYNC (60*5) /* sorry - but it just was not build as a clock */
578: #define DCF7000_SPEED (B9600)
579: #define DCF7000_CFLAG (CS8|CREAD|PARENB|PARODD|CLOCAL|HUPCL)
580: #define DCF7000_IFLAG (IGNBRK)
581: #define DCF7000_OFLAG 0
582: #define DCF7000_LFLAG 0
583: #define DCF7000_SAMPLES 5
584: #define DCF7000_KEEP 3
585: #define DCF7000_FORMAT "ELV DCF7000"
586:
587: /*
588: * Schmid DCF Receiver Kit
589: *
590: * When the WSDCF clock is operating optimally we want the primary clock
591: * distance to come out at 300 ms. Thus, peer.distance in the WSDCF peer
592: * structure is set to 290 ms and we compute delays which are at least
593: * 10 ms long. The following are 290 ms and 10 ms expressed in u_fp format
594: */
595: #define WS_POLLRATE 1 /* every second - watch interdependency with poll routine */
596: #define WS_POLLCMD "\163"
597: #define WS_CMDSIZE 1
598:
599: static poll_info_t wsdcf_pollinfo = { WS_POLLRATE, WS_POLLCMD, WS_CMDSIZE };
600:
601: #define WSDCF_INIT poll_init
602: #define WSDCF_POLL poll_dpoll
603: #define WSDCF_END 0
604: #define WSDCF_DATA ((void *)(&wsdcf_pollinfo))
605: #define WSDCF_ROOTDELAY 0.0 /* 0 */
606: #define WSDCF_BASEDELAY 0.010 /* ~ 10ms */
607: #define WSDCF_DESCRIPTION "WS/DCF Receiver"
608: #define WSDCF_FORMAT "Schmid"
609: #define WSDCF_MAXUNSYNC (60*60) /* assume this beast hold at 1 h better than 2 ms XXX-must verify */
610: #define WSDCF_SPEED (B1200)
611: #define WSDCF_CFLAG (CS8|CREAD|CLOCAL)
612: #define WSDCF_IFLAG 0
613: #define WSDCF_OFLAG 0
614: #define WSDCF_LFLAG 0
615: #define WSDCF_SAMPLES 5
616: #define WSDCF_KEEP 3
617:
618: /*
619: * RAW DCF77 - input of DCF marks via RS232 - many variants
620: */
621: #define RAWDCF_FLAGS 0
622: #define RAWDCF_ROOTDELAY 0.0 /* 0 */
623: #define RAWDCF_BASEDELAY 0.258
624: #define RAWDCF_FORMAT "RAW DCF77 Timecode"
625: #define RAWDCF_MAXUNSYNC (0) /* sorry - its a true receiver - no signal - no time */
626: #define RAWDCF_SPEED (B50)
627: #ifdef NO_PARENB_IGNPAR /* Was: defined(SYS_IRIX4) || defined(SYS_IRIX5) */
628: /* somehow doesn't grok PARENB & IGNPAR (mj) */
629: # define RAWDCF_CFLAG (CS8|CREAD|CLOCAL)
630: #else
631: # define RAWDCF_CFLAG (CS8|CREAD|CLOCAL|PARENB)
632: #endif
633: #ifdef RAWDCF_NO_IGNPAR /* Was: defined(SYS_LINUX) && defined(CLOCK_RAWDCF) */
634: # define RAWDCF_IFLAG 0
635: #else
636: # define RAWDCF_IFLAG (IGNPAR)
637: #endif
638: #define RAWDCF_OFLAG 0
639: #define RAWDCF_LFLAG 0
640: #define RAWDCF_SAMPLES 20
641: #define RAWDCF_KEEP 12
642: #define RAWDCF_INIT 0
643:
644: /*
645: * RAW DCF variants
646: */
647: /*
648: * Conrad receiver
649: *
650: * simplest (cheapest) DCF clock - e. g. DCF77 receiver by Conrad
651: * (~40DM - roughly $30 ) followed by a level converter for RS232
652: */
653: #define CONRAD_BASEDELAY 0.292 /* Conrad receiver @ 50 Baud on a Sun */
654: #define CONRAD_DESCRIPTION "RAW DCF77 CODE (Conrad DCF77 receiver module)"
655:
656: /* Gude Analog- und Digitalsystem GmbH 'Expert mouseCLOCK USB v2.0' */
657: #define GUDE_EMC_USB_V20_SPEED (B4800)
658: #define GUDE_EMC_USB_V20_BASEDELAY 0.425 /* USB serial<->USB converter FTDI232R */
659: #define GUDE_EMC_USB_V20_DESCRIPTION "RAW DCF77 CODE (Expert mouseCLOCK USB v2.0)"
660:
661: /*
662: * TimeBrick receiver
663: */
664: #define TIMEBRICK_BASEDELAY 0.210 /* TimeBrick @ 50 Baud on a Sun */
665: #define TIMEBRICK_DESCRIPTION "RAW DCF77 CODE (TimeBrick)"
666:
667: /*
668: * IGEL:clock receiver
669: */
670: #define IGELCLOCK_BASEDELAY 0.258 /* IGEL:clock receiver */
671: #define IGELCLOCK_DESCRIPTION "RAW DCF77 CODE (IGEL:clock)"
672: #define IGELCLOCK_SPEED (B1200)
673: #define IGELCLOCK_CFLAG (CS8|CREAD|HUPCL|CLOCAL)
674:
675: /*
676: * RAWDCF receivers that need to be powered from DTR
677: * (like Expert mouse clock)
678: */
679: static int rawdcf_init_1 (struct parseunit *);
680: #define RAWDCFDTRSET_DESCRIPTION "RAW DCF77 CODE (DTR SET/RTS CLR)"
681: #define RAWDCFDTRSET75_DESCRIPTION "RAW DCF77 CODE (DTR SET/RTS CLR @ 75 baud)"
682: #define RAWDCFDTRSET_INIT rawdcf_init_1
683:
684: /*
685: * RAWDCF receivers that need to be powered from
686: * DTR CLR and RTS SET
687: */
688: static int rawdcf_init_2 (struct parseunit *);
689: #define RAWDCFDTRCLRRTSSET_DESCRIPTION "RAW DCF77 CODE (DTR CLR/RTS SET)"
690: #define RAWDCFDTRCLRRTSSET75_DESCRIPTION "RAW DCF77 CODE (DTR CLR/RTS SET @ 75 baud)"
691: #define RAWDCFDTRCLRRTSSET_INIT rawdcf_init_2
692:
693: /*
694: * Trimble GPS receivers (TAIP and TSIP protocols)
695: */
696: #ifndef TRIM_POLLRATE
697: #define TRIM_POLLRATE 0 /* only true direct polling */
698: #endif
699:
700: #define TRIM_TAIPPOLLCMD ">SRM;FR_FLAG=F;EC_FLAG=F<>QTM<"
701: #define TRIM_TAIPCMDSIZE (sizeof(TRIM_TAIPPOLLCMD)-1)
702:
703: static poll_info_t trimbletaip_pollinfo = { TRIM_POLLRATE, TRIM_TAIPPOLLCMD, TRIM_TAIPCMDSIZE };
704: static int trimbletaip_init (struct parseunit *);
705: static void trimbletaip_event (struct parseunit *, int);
706:
707: /* query time & UTC correction data */
708: static char tsipquery[] = { DLE, 0x21, DLE, ETX, DLE, 0x2F, DLE, ETX };
709:
710: static poll_info_t trimbletsip_pollinfo = { TRIM_POLLRATE, tsipquery, sizeof(tsipquery) };
711: static int trimbletsip_init (struct parseunit *);
712: static void trimbletsip_end (struct parseunit *);
713: static void trimbletsip_message (struct parseunit *, parsetime_t *);
714: static void trimbletsip_event (struct parseunit *, int);
715:
716: #define TRIMBLETSIP_IDLE_TIME (300) /* 5 minutes silence at most */
717: #define TRIMBLE_RESET_HOLDOFF TRIMBLETSIP_IDLE_TIME
718:
719: #define TRIMBLETAIP_SPEED (B4800)
720: #define TRIMBLETAIP_CFLAG (CS8|CREAD|CLOCAL)
721: #define TRIMBLETAIP_IFLAG (BRKINT|IGNPAR|ISTRIP|ICRNL|IXON)
722: #define TRIMBLETAIP_OFLAG (OPOST|ONLCR)
723: #define TRIMBLETAIP_LFLAG (0)
724:
725: #define TRIMBLETSIP_SPEED (B9600)
726: #define TRIMBLETSIP_CFLAG (CS8|CLOCAL|CREAD|PARENB|PARODD)
727: #define TRIMBLETSIP_IFLAG (IGNBRK)
728: #define TRIMBLETSIP_OFLAG (0)
729: #define TRIMBLETSIP_LFLAG (ICANON)
730:
731: #define TRIMBLETSIP_SAMPLES 5
732: #define TRIMBLETSIP_KEEP 3
733: #define TRIMBLETAIP_SAMPLES 5
734: #define TRIMBLETAIP_KEEP 3
735:
736: #define TRIMBLETAIP_FLAGS (PARSE_F_PPSONSECOND)
737: #define TRIMBLETSIP_FLAGS (TRIMBLETAIP_FLAGS)
738:
739: #define TRIMBLETAIP_POLL poll_dpoll
740: #define TRIMBLETSIP_POLL poll_dpoll
741:
742: #define TRIMBLETAIP_INIT trimbletaip_init
743: #define TRIMBLETSIP_INIT trimbletsip_init
744:
745: #define TRIMBLETAIP_EVENT trimbletaip_event
746:
747: #define TRIMBLETSIP_EVENT trimbletsip_event
748: #define TRIMBLETSIP_MESSAGE trimbletsip_message
749:
750: #define TRIMBLETAIP_END 0
751: #define TRIMBLETSIP_END trimbletsip_end
752:
753: #define TRIMBLETAIP_DATA ((void *)(&trimbletaip_pollinfo))
754: #define TRIMBLETSIP_DATA ((void *)(&trimbletsip_pollinfo))
755:
756: #define TRIMBLETAIP_ID GPS_ID
757: #define TRIMBLETSIP_ID GPS_ID
758:
759: #define TRIMBLETAIP_FORMAT "Trimble TAIP"
760: #define TRIMBLETSIP_FORMAT "Trimble TSIP"
761:
762: #define TRIMBLETAIP_ROOTDELAY 0x0
763: #define TRIMBLETSIP_ROOTDELAY 0x0
764:
765: #define TRIMBLETAIP_BASEDELAY 0.0
766: #define TRIMBLETSIP_BASEDELAY 0.020 /* GPS time message latency */
767:
768: #define TRIMBLETAIP_DESCRIPTION "Trimble GPS (TAIP) receiver"
769: #define TRIMBLETSIP_DESCRIPTION "Trimble GPS (TSIP) receiver"
770:
771: #define TRIMBLETAIP_MAXUNSYNC 0
772: #define TRIMBLETSIP_MAXUNSYNC 0
773:
774: #define TRIMBLETAIP_EOL '<'
775:
776: /*
777: * RadioCode Clocks RCC 800 receiver
778: */
779: #define RCC_POLLRATE 0 /* only true direct polling */
780: #define RCC_POLLCMD "\r"
781: #define RCC_CMDSIZE 1
782:
783: static poll_info_t rcc8000_pollinfo = { RCC_POLLRATE, RCC_POLLCMD, RCC_CMDSIZE };
784: #define RCC8000_FLAGS 0
785: #define RCC8000_POLL poll_dpoll
786: #define RCC8000_INIT poll_init
787: #define RCC8000_END 0
788: #define RCC8000_DATA ((void *)(&rcc8000_pollinfo))
789: #define RCC8000_ROOTDELAY 0.0
790: #define RCC8000_BASEDELAY 0.0
791: #define RCC8000_ID "MSF"
792: #define RCC8000_DESCRIPTION "RCC 8000 MSF Receiver"
793: #define RCC8000_FORMAT "Radiocode RCC8000"
794: #define RCC8000_MAXUNSYNC (60*60) /* should be ok for an hour */
795: #define RCC8000_SPEED (B2400)
796: #define RCC8000_CFLAG (CS8|CREAD|CLOCAL)
797: #define RCC8000_IFLAG (IGNBRK|IGNPAR)
798: #define RCC8000_OFLAG 0
799: #define RCC8000_LFLAG 0
800: #define RCC8000_SAMPLES 5
801: #define RCC8000_KEEP 3
802:
803: /*
804: * Hopf Radio clock 6021 Format
805: *
806: */
807: #define HOPF6021_ROOTDELAY 0.0
808: #define HOPF6021_BASEDELAY 0.0
809: #define HOPF6021_DESCRIPTION "HOPF 6021"
810: #define HOPF6021_FORMAT "hopf Funkuhr 6021"
811: #define HOPF6021_MAXUNSYNC (60*60) /* should be ok for an hour */
812: #define HOPF6021_SPEED (B9600)
813: #define HOPF6021_CFLAG (CS8|CREAD|CLOCAL)
814: #define HOPF6021_IFLAG (IGNBRK|ISTRIP)
815: #define HOPF6021_OFLAG 0
816: #define HOPF6021_LFLAG 0
817: #define HOPF6021_FLAGS 0
818: #define HOPF6021_SAMPLES 5
819: #define HOPF6021_KEEP 3
820:
821: /*
822: * Diem's Computime Radio Clock Receiver
823: */
824: #define COMPUTIME_FLAGS 0
825: #define COMPUTIME_ROOTDELAY 0.0
826: #define COMPUTIME_BASEDELAY 0.0
827: #define COMPUTIME_ID DCF_ID
828: #define COMPUTIME_DESCRIPTION "Diem's Computime receiver"
829: #define COMPUTIME_FORMAT "Diem's Computime Radio Clock"
830: #define COMPUTIME_TYPE DCF_TYPE
831: #define COMPUTIME_MAXUNSYNC (60*60) /* only trust clock for 1 hour */
832: #define COMPUTIME_SPEED (B9600)
833: #define COMPUTIME_CFLAG (CSTOPB|CS7|CREAD|CLOCAL)
834: #define COMPUTIME_IFLAG (IGNBRK|IGNPAR|ISTRIP)
835: #define COMPUTIME_OFLAG 0
836: #define COMPUTIME_LFLAG 0
837: #define COMPUTIME_SAMPLES 5
838: #define COMPUTIME_KEEP 3
839:
840: /*
841: * Varitext Radio Clock Receiver
842: */
843: #define VARITEXT_FLAGS 0
844: #define VARITEXT_ROOTDELAY 0.0
845: #define VARITEXT_BASEDELAY 0.0
846: #define VARITEXT_ID "MSF"
847: #define VARITEXT_DESCRIPTION "Varitext receiver"
848: #define VARITEXT_FORMAT "Varitext Radio Clock"
849: #define VARITEXT_TYPE DCF_TYPE
850: #define VARITEXT_MAXUNSYNC (60*60) /* only trust clock for 1 hour */
851: #define VARITEXT_SPEED (B9600)
852: #define VARITEXT_CFLAG (CS7|CREAD|CLOCAL|PARENB|PARODD)
853: #define VARITEXT_IFLAG (IGNPAR|IGNBRK|INPCK) /*|ISTRIP)*/
854: #define VARITEXT_OFLAG 0
855: #define VARITEXT_LFLAG 0
856: #define VARITEXT_SAMPLES 32
857: #define VARITEXT_KEEP 20
858:
859: static struct parse_clockinfo
860: {
861: u_long cl_flags; /* operation flags (PPS interpretation, trust handling) */
862: void (*cl_poll) (struct parseunit *); /* active poll routine */
863: int (*cl_init) (struct parseunit *); /* active poll init routine */
864: void (*cl_event) (struct parseunit *, int); /* special event handling (e.g. reset clock) */
865: void (*cl_end) (struct parseunit *); /* active poll end routine */
866: void (*cl_message) (struct parseunit *, parsetime_t *); /* process a lower layer message */
867: void *cl_data; /* local data area for "poll" mechanism */
868: double cl_rootdelay; /* rootdelay */
869: double cl_basedelay; /* current offset by which the RS232
870: time code is delayed from the actual time */
871: const char *cl_id; /* ID code */
872: const char *cl_description; /* device name */
873: const char *cl_format; /* fixed format */
874: u_char cl_type; /* clock type (ntp control) */
875: u_long cl_maxunsync; /* time to trust oscillator after losing synch */
876: u_long cl_speed; /* terminal input & output baudrate */
877: u_long cl_cflag; /* terminal control flags */
878: u_long cl_iflag; /* terminal input flags */
879: u_long cl_oflag; /* terminal output flags */
880: u_long cl_lflag; /* terminal local flags */
881: u_long cl_samples; /* samples for median filter */
882: u_long cl_keep; /* samples for median filter to keep */
883: } parse_clockinfo[] =
884: {
885: { /* mode 0 */
886: MBG_FLAGS,
887: NO_POLL,
888: NO_INIT,
889: NO_EVENT,
890: NO_END,
891: NO_MESSAGE,
892: NO_LCLDATA,
893: DCFPZF535_ROOTDELAY,
894: DCFPZF535_BASEDELAY,
895: DCF_P_ID,
896: DCFPZF535_DESCRIPTION,
897: DCFPZF535_FORMAT,
898: DCF_TYPE,
899: DCFPZF535_MAXUNSYNC,
900: DCFPZF535_SPEED,
901: DCFPZF535_CFLAG,
902: DCFPZF535_IFLAG,
903: DCFPZF535_OFLAG,
904: DCFPZF535_LFLAG,
905: DCFPZF535_SAMPLES,
906: DCFPZF535_KEEP
907: },
908: { /* mode 1 */
909: MBG_FLAGS,
910: NO_POLL,
911: NO_INIT,
912: NO_EVENT,
913: NO_END,
914: NO_MESSAGE,
915: NO_LCLDATA,
916: DCFPZF535OCXO_ROOTDELAY,
917: DCFPZF535OCXO_BASEDELAY,
918: DCF_P_ID,
919: DCFPZF535OCXO_DESCRIPTION,
920: DCFPZF535OCXO_FORMAT,
921: DCF_TYPE,
922: DCFPZF535OCXO_MAXUNSYNC,
923: DCFPZF535OCXO_SPEED,
924: DCFPZF535OCXO_CFLAG,
925: DCFPZF535OCXO_IFLAG,
926: DCFPZF535OCXO_OFLAG,
927: DCFPZF535OCXO_LFLAG,
928: DCFPZF535OCXO_SAMPLES,
929: DCFPZF535OCXO_KEEP
930: },
931: { /* mode 2 */
932: MBG_FLAGS,
933: NO_POLL,
934: NO_INIT,
935: NO_EVENT,
936: NO_END,
937: NO_MESSAGE,
938: NO_LCLDATA,
939: DCFUA31_ROOTDELAY,
940: DCFUA31_BASEDELAY,
941: DCF_A_ID,
942: DCFUA31_DESCRIPTION,
943: DCFUA31_FORMAT,
944: DCF_TYPE,
945: DCFUA31_MAXUNSYNC,
946: DCFUA31_SPEED,
947: DCFUA31_CFLAG,
948: DCFUA31_IFLAG,
949: DCFUA31_OFLAG,
950: DCFUA31_LFLAG,
951: DCFUA31_SAMPLES,
952: DCFUA31_KEEP
953: },
954: { /* mode 3 */
955: MBG_FLAGS,
956: NO_POLL,
957: NO_INIT,
958: NO_EVENT,
959: NO_END,
960: NO_MESSAGE,
961: NO_LCLDATA,
962: DCF7000_ROOTDELAY,
963: DCF7000_BASEDELAY,
964: DCF_A_ID,
965: DCF7000_DESCRIPTION,
966: DCF7000_FORMAT,
967: DCF_TYPE,
968: DCF7000_MAXUNSYNC,
969: DCF7000_SPEED,
970: DCF7000_CFLAG,
971: DCF7000_IFLAG,
972: DCF7000_OFLAG,
973: DCF7000_LFLAG,
974: DCF7000_SAMPLES,
975: DCF7000_KEEP
976: },
977: { /* mode 4 */
978: NO_CL_FLAGS,
979: WSDCF_POLL,
980: WSDCF_INIT,
981: NO_EVENT,
982: WSDCF_END,
983: NO_MESSAGE,
984: WSDCF_DATA,
985: WSDCF_ROOTDELAY,
986: WSDCF_BASEDELAY,
987: DCF_A_ID,
988: WSDCF_DESCRIPTION,
989: WSDCF_FORMAT,
990: DCF_TYPE,
991: WSDCF_MAXUNSYNC,
992: WSDCF_SPEED,
993: WSDCF_CFLAG,
994: WSDCF_IFLAG,
995: WSDCF_OFLAG,
996: WSDCF_LFLAG,
997: WSDCF_SAMPLES,
998: WSDCF_KEEP
999: },
1000: { /* mode 5 */
1001: RAWDCF_FLAGS,
1002: NO_POLL,
1003: RAWDCF_INIT,
1004: NO_EVENT,
1005: NO_END,
1006: NO_MESSAGE,
1007: NO_LCLDATA,
1008: RAWDCF_ROOTDELAY,
1009: CONRAD_BASEDELAY,
1010: DCF_A_ID,
1011: CONRAD_DESCRIPTION,
1012: RAWDCF_FORMAT,
1013: DCF_TYPE,
1014: RAWDCF_MAXUNSYNC,
1015: RAWDCF_SPEED,
1016: RAWDCF_CFLAG,
1017: RAWDCF_IFLAG,
1018: RAWDCF_OFLAG,
1019: RAWDCF_LFLAG,
1020: RAWDCF_SAMPLES,
1021: RAWDCF_KEEP
1022: },
1023: { /* mode 6 */
1024: RAWDCF_FLAGS,
1025: NO_POLL,
1026: RAWDCF_INIT,
1027: NO_EVENT,
1028: NO_END,
1029: NO_MESSAGE,
1030: NO_LCLDATA,
1031: RAWDCF_ROOTDELAY,
1032: TIMEBRICK_BASEDELAY,
1033: DCF_A_ID,
1034: TIMEBRICK_DESCRIPTION,
1035: RAWDCF_FORMAT,
1036: DCF_TYPE,
1037: RAWDCF_MAXUNSYNC,
1038: RAWDCF_SPEED,
1039: RAWDCF_CFLAG,
1040: RAWDCF_IFLAG,
1041: RAWDCF_OFLAG,
1042: RAWDCF_LFLAG,
1043: RAWDCF_SAMPLES,
1044: RAWDCF_KEEP
1045: },
1046: { /* mode 7 */
1047: MBG_FLAGS,
1048: GPS16X_POLL,
1049: GPS16X_INIT,
1050: NO_EVENT,
1051: GPS16X_END,
1052: GPS16X_MESSAGE,
1053: GPS16X_DATA,
1054: GPS16X_ROOTDELAY,
1055: GPS16X_BASEDELAY,
1056: GPS16X_ID,
1057: GPS16X_DESCRIPTION,
1058: GPS16X_FORMAT,
1059: GPS_TYPE,
1060: GPS16X_MAXUNSYNC,
1061: GPS16X_SPEED,
1062: GPS16X_CFLAG,
1063: GPS16X_IFLAG,
1064: GPS16X_OFLAG,
1065: GPS16X_LFLAG,
1066: GPS16X_SAMPLES,
1067: GPS16X_KEEP
1068: },
1069: { /* mode 8 */
1070: RAWDCF_FLAGS,
1071: NO_POLL,
1072: NO_INIT,
1073: NO_EVENT,
1074: NO_END,
1075: NO_MESSAGE,
1076: NO_LCLDATA,
1077: RAWDCF_ROOTDELAY,
1078: IGELCLOCK_BASEDELAY,
1079: DCF_A_ID,
1080: IGELCLOCK_DESCRIPTION,
1081: RAWDCF_FORMAT,
1082: DCF_TYPE,
1083: RAWDCF_MAXUNSYNC,
1084: IGELCLOCK_SPEED,
1085: IGELCLOCK_CFLAG,
1086: RAWDCF_IFLAG,
1087: RAWDCF_OFLAG,
1088: RAWDCF_LFLAG,
1089: RAWDCF_SAMPLES,
1090: RAWDCF_KEEP
1091: },
1092: { /* mode 9 */
1093: TRIMBLETAIP_FLAGS,
1094: #if TRIM_POLLRATE /* DHD940515: Allow user config */
1095: NO_POLL,
1096: #else
1097: TRIMBLETAIP_POLL,
1098: #endif
1099: TRIMBLETAIP_INIT,
1100: TRIMBLETAIP_EVENT,
1101: TRIMBLETAIP_END,
1102: NO_MESSAGE,
1103: TRIMBLETAIP_DATA,
1104: TRIMBLETAIP_ROOTDELAY,
1105: TRIMBLETAIP_BASEDELAY,
1106: TRIMBLETAIP_ID,
1107: TRIMBLETAIP_DESCRIPTION,
1108: TRIMBLETAIP_FORMAT,
1109: GPS_TYPE,
1110: TRIMBLETAIP_MAXUNSYNC,
1111: TRIMBLETAIP_SPEED,
1112: TRIMBLETAIP_CFLAG,
1113: TRIMBLETAIP_IFLAG,
1114: TRIMBLETAIP_OFLAG,
1115: TRIMBLETAIP_LFLAG,
1116: TRIMBLETAIP_SAMPLES,
1117: TRIMBLETAIP_KEEP
1118: },
1119: { /* mode 10 */
1120: TRIMBLETSIP_FLAGS,
1121: #if TRIM_POLLRATE /* DHD940515: Allow user config */
1122: NO_POLL,
1123: #else
1124: TRIMBLETSIP_POLL,
1125: #endif
1126: TRIMBLETSIP_INIT,
1127: TRIMBLETSIP_EVENT,
1128: TRIMBLETSIP_END,
1129: TRIMBLETSIP_MESSAGE,
1130: TRIMBLETSIP_DATA,
1131: TRIMBLETSIP_ROOTDELAY,
1132: TRIMBLETSIP_BASEDELAY,
1133: TRIMBLETSIP_ID,
1134: TRIMBLETSIP_DESCRIPTION,
1135: TRIMBLETSIP_FORMAT,
1136: GPS_TYPE,
1137: TRIMBLETSIP_MAXUNSYNC,
1138: TRIMBLETSIP_SPEED,
1139: TRIMBLETSIP_CFLAG,
1140: TRIMBLETSIP_IFLAG,
1141: TRIMBLETSIP_OFLAG,
1142: TRIMBLETSIP_LFLAG,
1143: TRIMBLETSIP_SAMPLES,
1144: TRIMBLETSIP_KEEP
1145: },
1146: { /* mode 11 */
1147: NO_CL_FLAGS,
1148: RCC8000_POLL,
1149: RCC8000_INIT,
1150: NO_EVENT,
1151: RCC8000_END,
1152: NO_MESSAGE,
1153: RCC8000_DATA,
1154: RCC8000_ROOTDELAY,
1155: RCC8000_BASEDELAY,
1156: RCC8000_ID,
1157: RCC8000_DESCRIPTION,
1158: RCC8000_FORMAT,
1159: DCF_TYPE,
1160: RCC8000_MAXUNSYNC,
1161: RCC8000_SPEED,
1162: RCC8000_CFLAG,
1163: RCC8000_IFLAG,
1164: RCC8000_OFLAG,
1165: RCC8000_LFLAG,
1166: RCC8000_SAMPLES,
1167: RCC8000_KEEP
1168: },
1169: { /* mode 12 */
1170: HOPF6021_FLAGS,
1171: NO_POLL,
1172: NO_INIT,
1173: NO_EVENT,
1174: NO_END,
1175: NO_MESSAGE,
1176: NO_LCLDATA,
1177: HOPF6021_ROOTDELAY,
1178: HOPF6021_BASEDELAY,
1179: DCF_ID,
1180: HOPF6021_DESCRIPTION,
1181: HOPF6021_FORMAT,
1182: DCF_TYPE,
1183: HOPF6021_MAXUNSYNC,
1184: HOPF6021_SPEED,
1185: HOPF6021_CFLAG,
1186: HOPF6021_IFLAG,
1187: HOPF6021_OFLAG,
1188: HOPF6021_LFLAG,
1189: HOPF6021_SAMPLES,
1190: HOPF6021_KEEP
1191: },
1192: { /* mode 13 */
1193: COMPUTIME_FLAGS,
1194: NO_POLL,
1195: NO_INIT,
1196: NO_EVENT,
1197: NO_END,
1198: NO_MESSAGE,
1199: NO_LCLDATA,
1200: COMPUTIME_ROOTDELAY,
1201: COMPUTIME_BASEDELAY,
1202: COMPUTIME_ID,
1203: COMPUTIME_DESCRIPTION,
1204: COMPUTIME_FORMAT,
1205: COMPUTIME_TYPE,
1206: COMPUTIME_MAXUNSYNC,
1207: COMPUTIME_SPEED,
1208: COMPUTIME_CFLAG,
1209: COMPUTIME_IFLAG,
1210: COMPUTIME_OFLAG,
1211: COMPUTIME_LFLAG,
1212: COMPUTIME_SAMPLES,
1213: COMPUTIME_KEEP
1214: },
1215: { /* mode 14 */
1216: RAWDCF_FLAGS,
1217: NO_POLL,
1218: RAWDCFDTRSET_INIT,
1219: NO_EVENT,
1220: NO_END,
1221: NO_MESSAGE,
1222: NO_LCLDATA,
1223: RAWDCF_ROOTDELAY,
1224: RAWDCF_BASEDELAY,
1225: DCF_A_ID,
1226: RAWDCFDTRSET_DESCRIPTION,
1227: RAWDCF_FORMAT,
1228: DCF_TYPE,
1229: RAWDCF_MAXUNSYNC,
1230: RAWDCF_SPEED,
1231: RAWDCF_CFLAG,
1232: RAWDCF_IFLAG,
1233: RAWDCF_OFLAG,
1234: RAWDCF_LFLAG,
1235: RAWDCF_SAMPLES,
1236: RAWDCF_KEEP
1237: },
1238: { /* mode 15 */
1239: 0, /* operation flags (io modes) */
1240: NO_POLL, /* active poll routine */
1241: NO_INIT, /* active poll init routine */
1242: NO_EVENT, /* special event handling (e.g. reset clock) */
1243: NO_END, /* active poll end routine */
1244: NO_MESSAGE, /* process a lower layer message */
1245: NO_LCLDATA, /* local data area for "poll" mechanism */
1246: 0, /* rootdelay */
1247: 11.0 /* bits */ / 9600, /* current offset by which the RS232
1248: time code is delayed from the actual time */
1249: DCF_ID, /* ID code */
1250: "WHARTON 400A Series clock", /* device name */
1251: "WHARTON 400A Series clock Output Format 1", /* fixed format */
1252: /* Must match a format-name in a libparse/clk_xxx.c file */
1253: DCF_TYPE, /* clock type (ntp control) */
1254: (1*60*60), /* time to trust oscillator after losing synch */
1255: B9600, /* terminal input & output baudrate */
1256: (CS8|CREAD|PARENB|CLOCAL|HUPCL),/* terminal control flags */
1257: 0, /* terminal input flags */
1258: 0, /* terminal output flags */
1259: 0, /* terminal local flags */
1260: 5, /* samples for median filter */
1261: 3, /* samples for median filter to keep */
1262: },
1263: { /* mode 16 - RAWDCF RTS set, DTR clr */
1264: RAWDCF_FLAGS,
1265: NO_POLL,
1266: RAWDCFDTRCLRRTSSET_INIT,
1267: NO_EVENT,
1268: NO_END,
1269: NO_MESSAGE,
1270: NO_LCLDATA,
1271: RAWDCF_ROOTDELAY,
1272: RAWDCF_BASEDELAY,
1273: DCF_A_ID,
1274: RAWDCFDTRCLRRTSSET_DESCRIPTION,
1275: RAWDCF_FORMAT,
1276: DCF_TYPE,
1277: RAWDCF_MAXUNSYNC,
1278: RAWDCF_SPEED,
1279: RAWDCF_CFLAG,
1280: RAWDCF_IFLAG,
1281: RAWDCF_OFLAG,
1282: RAWDCF_LFLAG,
1283: RAWDCF_SAMPLES,
1284: RAWDCF_KEEP
1285: },
1286: { /* mode 17 */
1287: VARITEXT_FLAGS,
1288: NO_POLL,
1289: NO_INIT,
1290: NO_EVENT,
1291: NO_END,
1292: NO_MESSAGE,
1293: NO_LCLDATA,
1294: VARITEXT_ROOTDELAY,
1295: VARITEXT_BASEDELAY,
1296: VARITEXT_ID,
1297: VARITEXT_DESCRIPTION,
1298: VARITEXT_FORMAT,
1299: VARITEXT_TYPE,
1300: VARITEXT_MAXUNSYNC,
1301: VARITEXT_SPEED,
1302: VARITEXT_CFLAG,
1303: VARITEXT_IFLAG,
1304: VARITEXT_OFLAG,
1305: VARITEXT_LFLAG,
1306: VARITEXT_SAMPLES,
1307: VARITEXT_KEEP
1308: },
1309: { /* mode 18 */
1310: MBG_FLAGS,
1311: NO_POLL,
1312: NO_INIT,
1313: NO_EVENT,
1314: GPS16X_END,
1315: GPS16X_MESSAGE,
1316: GPS16X_DATA,
1317: GPS16X_ROOTDELAY,
1318: GPS16X_BASEDELAY,
1319: GPS16X_ID,
1320: GPS16X_DESCRIPTION,
1321: GPS16X_FORMAT,
1322: GPS_TYPE,
1323: GPS16X_MAXUNSYNC,
1324: GPS16X_SPEED,
1325: GPS16X_CFLAG,
1326: GPS16X_IFLAG,
1327: GPS16X_OFLAG,
1328: GPS16X_LFLAG,
1329: GPS16X_SAMPLES,
1330: GPS16X_KEEP
1331: },
1332: { /* mode 19 */
1333: RAWDCF_FLAGS,
1334: NO_POLL,
1335: RAWDCF_INIT,
1336: NO_EVENT,
1337: NO_END,
1338: NO_MESSAGE,
1339: NO_LCLDATA,
1340: RAWDCF_ROOTDELAY,
1341: GUDE_EMC_USB_V20_BASEDELAY,
1342: DCF_A_ID,
1343: GUDE_EMC_USB_V20_DESCRIPTION,
1344: RAWDCF_FORMAT,
1345: DCF_TYPE,
1346: RAWDCF_MAXUNSYNC,
1347: GUDE_EMC_USB_V20_SPEED,
1348: RAWDCF_CFLAG,
1349: RAWDCF_IFLAG,
1350: RAWDCF_OFLAG,
1351: RAWDCF_LFLAG,
1352: RAWDCF_SAMPLES,
1353: RAWDCF_KEEP
1354: },
1355: { /* mode 20, like mode 14 but driven by 75 baud */
1356: RAWDCF_FLAGS,
1357: NO_POLL,
1358: RAWDCFDTRSET_INIT,
1359: NO_EVENT,
1360: NO_END,
1361: NO_MESSAGE,
1362: NO_LCLDATA,
1363: RAWDCF_ROOTDELAY,
1364: RAWDCF_BASEDELAY,
1365: DCF_A_ID,
1366: RAWDCFDTRSET75_DESCRIPTION,
1367: RAWDCF_FORMAT,
1368: DCF_TYPE,
1369: RAWDCF_MAXUNSYNC,
1370: B75,
1371: RAWDCF_CFLAG,
1372: RAWDCF_IFLAG,
1373: RAWDCF_OFLAG,
1374: RAWDCF_LFLAG,
1375: RAWDCF_SAMPLES,
1376: RAWDCF_KEEP
1377: },
1378: { /* mode 21, like mode 16 but driven by 75 baud
1379: - RAWDCF RTS set, DTR clr */
1380: RAWDCF_FLAGS,
1381: NO_POLL,
1382: RAWDCFDTRCLRRTSSET_INIT,
1383: NO_EVENT,
1384: NO_END,
1385: NO_MESSAGE,
1386: NO_LCLDATA,
1387: RAWDCF_ROOTDELAY,
1388: RAWDCF_BASEDELAY,
1389: DCF_A_ID,
1390: RAWDCFDTRCLRRTSSET75_DESCRIPTION,
1391: RAWDCF_FORMAT,
1392: DCF_TYPE,
1393: RAWDCF_MAXUNSYNC,
1394: B75,
1395: RAWDCF_CFLAG,
1396: RAWDCF_IFLAG,
1397: RAWDCF_OFLAG,
1398: RAWDCF_LFLAG,
1399: RAWDCF_SAMPLES,
1400: RAWDCF_KEEP
1401: },
1402: { /* mode 22 - like 2 with POWERUP trust */
1403: MBG_FLAGS | PARSE_F_POWERUPTRUST,
1404: NO_POLL,
1405: NO_INIT,
1406: NO_EVENT,
1407: NO_END,
1408: NO_MESSAGE,
1409: NO_LCLDATA,
1410: DCFUA31_ROOTDELAY,
1411: DCFUA31_BASEDELAY,
1412: DCF_A_ID,
1413: DCFUA31_DESCRIPTION,
1414: DCFUA31_FORMAT,
1415: DCF_TYPE,
1416: DCFUA31_MAXUNSYNC,
1417: DCFUA31_SPEED,
1418: DCFUA31_CFLAG,
1419: DCFUA31_IFLAG,
1420: DCFUA31_OFLAG,
1421: DCFUA31_LFLAG,
1422: DCFUA31_SAMPLES,
1423: DCFUA31_KEEP
1424: },
1425: { /* mode 23 - like 7 with POWERUP trust */
1426: MBG_FLAGS | PARSE_F_POWERUPTRUST,
1427: GPS16X_POLL,
1428: GPS16X_INIT,
1429: NO_EVENT,
1430: GPS16X_END,
1431: GPS16X_MESSAGE,
1432: GPS16X_DATA,
1433: GPS16X_ROOTDELAY,
1434: GPS16X_BASEDELAY,
1435: GPS16X_ID,
1436: GPS16X_DESCRIPTION,
1437: GPS16X_FORMAT,
1438: GPS_TYPE,
1439: GPS16X_MAXUNSYNC,
1440: GPS16X_SPEED,
1441: GPS16X_CFLAG,
1442: GPS16X_IFLAG,
1443: GPS16X_OFLAG,
1444: GPS16X_LFLAG,
1445: GPS16X_SAMPLES,
1446: GPS16X_KEEP
1447: },
1448: };
1449:
1450: static int ncltypes = sizeof(parse_clockinfo) / sizeof(struct parse_clockinfo);
1451:
1452: #define CLK_REALTYPE(x) ((int)(((x)->ttl) & 0x7F))
1453: #define CLK_TYPE(x) ((CLK_REALTYPE(x) >= ncltypes) ? ~0 : CLK_REALTYPE(x))
1454: #define CLK_UNIT(x) ((int)REFCLOCKUNIT(&(x)->srcadr))
1455: #define CLK_PPS(x) (((x)->ttl) & 0x80)
1456:
1457: /*
1458: * Other constant stuff
1459: */
1460: #define PARSEHSREFID 0x7f7f08ff /* 127.127.8.255 refid for hi strata */
1461:
1462: #define PARSESTATISTICS (60*60) /* output state statistics every hour */
1463:
1464: static int notice = 0;
1465:
1466: #define PARSE_STATETIME(parse, i) ((parse->generic->currentstatus == i) ? parse->statetime[i] + current_time - parse->lastchange : parse->statetime[i])
1467:
1468: static void parse_event (struct parseunit *, int);
1469: static void parse_process (struct parseunit *, parsetime_t *);
1470: static void clear_err (struct parseunit *, u_long);
1471: static int list_err (struct parseunit *, u_long);
1472: static char * l_mktime (u_long);
1473:
1474: /**===========================================================================
1475: ** implementation error message regression module
1476: **/
1477: static void
1478: clear_err(
1479: struct parseunit *parse,
1480: u_long lstate
1481: )
1482: {
1483: if (lstate == ERR_ALL)
1484: {
1485: int i;
1486:
1487: for (i = 0; i < ERR_CNT; i++)
1488: {
1489: parse->errors[i].err_stage = err_tbl[i];
1490: parse->errors[i].err_cnt = 0;
1491: parse->errors[i].err_last = 0;
1492: parse->errors[i].err_started = 0;
1493: parse->errors[i].err_suppressed = 0;
1494: }
1495: }
1496: else
1497: {
1498: parse->errors[lstate].err_stage = err_tbl[lstate];
1499: parse->errors[lstate].err_cnt = 0;
1500: parse->errors[lstate].err_last = 0;
1501: parse->errors[lstate].err_started = 0;
1502: parse->errors[lstate].err_suppressed = 0;
1503: }
1504: }
1505:
1506: static int
1507: list_err(
1508: struct parseunit *parse,
1509: u_long lstate
1510: )
1511: {
1512: int do_it;
1513: struct errorinfo *err = &parse->errors[lstate];
1514:
1515: if (err->err_started == 0)
1516: {
1517: err->err_started = current_time;
1518: }
1519:
1520: do_it = (current_time - err->err_last) >= err->err_stage->err_delay;
1521:
1522: if (do_it)
1523: err->err_cnt++;
1524:
1525: if (err->err_stage->err_count &&
1526: (err->err_cnt >= err->err_stage->err_count))
1527: {
1528: err->err_stage++;
1529: err->err_cnt = 0;
1530: }
1531:
1532: if (!err->err_cnt && do_it)
1533: msyslog(LOG_INFO, "PARSE receiver #%d: interval for following error message class is at least %s",
1534: CLK_UNIT(parse->peer), l_mktime(err->err_stage->err_delay));
1535:
1536: if (!do_it)
1537: err->err_suppressed++;
1538: else
1539: err->err_last = current_time;
1540:
1541: if (do_it && err->err_suppressed)
1542: {
1543: msyslog(LOG_INFO, "PARSE receiver #%d: %ld message%s suppressed, error condition class persists for %s",
1544: CLK_UNIT(parse->peer), err->err_suppressed, (err->err_suppressed == 1) ? " was" : "s where",
1545: l_mktime(current_time - err->err_started));
1546: err->err_suppressed = 0;
1547: }
1548:
1549: return do_it;
1550: }
1551:
1552: /*--------------------------------------------------
1553: * mkreadable - make a printable ascii string (without
1554: * embedded quotes so that the ntpq protocol isn't
1555: * fooled
1556: */
1557: #ifndef isprint
1558: #define isprint(_X_) (((_X_) > 0x1F) && ((_X_) < 0x7F))
1559: #endif
1560:
1561: static char *
1562: mkreadable(
1563: char *buffer,
1564: long blen,
1565: const char *src,
1566: u_long srclen,
1567: int hex
1568: )
1569: {
1570: char *b = buffer;
1571: char *endb = NULL;
1572:
1573: if (blen < 4)
1574: return NULL; /* don't bother with mini buffers */
1575:
1576: endb = buffer + blen - 4;
1577:
1578: blen--; /* account for '\0' */
1579:
1580: while (blen && srclen--)
1581: {
1582: if (!hex && /* no binary only */
1583: (*src != '\\') && /* no plain \ */
1584: (*src != '"') && /* no " */
1585: isprint((int)*src)) /* only printables */
1586: { /* they are easy... */
1587: *buffer++ = *src++;
1588: blen--;
1589: }
1590: else
1591: {
1592: if (blen < 4)
1593: {
1594: while (blen--)
1595: {
1596: *buffer++ = '.';
1597: }
1598: *buffer = '\0';
1599: return b;
1600: }
1601: else
1602: {
1603: if (*src == '\\')
1604: {
1605: strcpy(buffer,"\\\\");
1606: buffer += 2;
1607: blen -= 2;
1608: src++;
1609: }
1610: else
1611: {
1612: snprintf(buffer, blen, "\\x%02x", *src++);
1613: blen -= 4;
1614: buffer += 4;
1615: }
1616: }
1617: }
1618: if (srclen && !blen && endb) /* overflow - set last chars to ... */
1619: strcpy(endb, "...");
1620: }
1621:
1622: *buffer = '\0';
1623: return b;
1624: }
1625:
1626:
1627: /*--------------------------------------------------
1628: * mkascii - make a printable ascii string
1629: * assumes (unless defined better) 7-bit ASCII
1630: */
1631: static char *
1632: mkascii(
1633: char *buffer,
1634: long blen,
1635: const char *src,
1636: u_long srclen
1637: )
1638: {
1639: return mkreadable(buffer, blen, src, srclen, 0);
1640: }
1641:
1642: /**===========================================================================
1643: ** implementation of i/o handling methods
1644: ** (all STREAM, partial STREAM, user level)
1645: **/
1646:
1647: /*
1648: * define possible io handling methods
1649: */
1650: #ifdef STREAM
1651: static int ppsclock_init (struct parseunit *);
1652: static int stream_init (struct parseunit *);
1653: static void stream_end (struct parseunit *);
1654: static int stream_enable (struct parseunit *);
1655: static int stream_disable (struct parseunit *);
1656: static int stream_setcs (struct parseunit *, parsectl_t *);
1657: static int stream_getfmt (struct parseunit *, parsectl_t *);
1658: static int stream_setfmt (struct parseunit *, parsectl_t *);
1659: static int stream_timecode (struct parseunit *, parsectl_t *);
1660: static void stream_receive (struct recvbuf *);
1661: #endif
1662:
1663: static int local_init (struct parseunit *);
1664: static void local_end (struct parseunit *);
1665: static int local_nop (struct parseunit *);
1666: static int local_setcs (struct parseunit *, parsectl_t *);
1667: static int local_getfmt (struct parseunit *, parsectl_t *);
1668: static int local_setfmt (struct parseunit *, parsectl_t *);
1669: static int local_timecode (struct parseunit *, parsectl_t *);
1670: static void local_receive (struct recvbuf *);
1671: static int local_input (struct recvbuf *);
1672:
1673: static bind_t io_bindings[] =
1674: {
1675: #ifdef STREAM
1676: {
1677: "parse STREAM",
1678: stream_init,
1679: stream_end,
1680: stream_setcs,
1681: stream_disable,
1682: stream_enable,
1683: stream_getfmt,
1684: stream_setfmt,
1685: stream_timecode,
1686: stream_receive,
1687: 0,
1688: },
1689: {
1690: "ppsclock STREAM",
1691: ppsclock_init,
1692: local_end,
1693: local_setcs,
1694: local_nop,
1695: local_nop,
1696: local_getfmt,
1697: local_setfmt,
1698: local_timecode,
1699: local_receive,
1700: local_input,
1701: },
1702: #endif
1703: {
1704: "normal",
1705: local_init,
1706: local_end,
1707: local_setcs,
1708: local_nop,
1709: local_nop,
1710: local_getfmt,
1711: local_setfmt,
1712: local_timecode,
1713: local_receive,
1714: local_input,
1715: },
1716: {
1717: (char *)0,
1718: }
1719: };
1720:
1721: #ifdef STREAM
1722:
1723: #define fix_ts(_X_) \
1724: if ((&(_X_))->tv.tv_usec >= 1000000) \
1725: { \
1726: (&(_X_))->tv.tv_usec -= 1000000; \
1727: (&(_X_))->tv.tv_sec += 1; \
1728: }
1729:
1730: #define cvt_ts(_X_, _Y_) \
1731: { \
1732: l_fp ts; \
1733: fix_ts((_X_)); \
1734: if (!buftvtots((const char *)&(&(_X_))->tv, &ts)) \
1735: { \
1736: ERR(ERR_BADDATA) \
1737: msyslog(LOG_ERR,"parse: stream_receive: timestamp conversion error (buftvtots) (%s) (%ld.%06ld) ", (_Y_), (long)(&(_X_))->tv.tv_sec, (long)(&(_X_))->tv.tv_usec);\
1738: return; \
1739: } \
1740: else \
1741: { \
1742: (&(_X_))->fp = ts; \
1743: } \
1744: }
1745:
1746: /*--------------------------------------------------
1747: * ppsclock STREAM init
1748: */
1749: static int
1750: ppsclock_init(
1751: struct parseunit *parse
1752: )
1753: {
1754: static char m1[] = "ppsclocd";
1755: static char m2[] = "ppsclock";
1756:
1757: /*
1758: * now push the parse streams module
1759: * it will ensure exclusive access to the device
1760: */
1761: if (ioctl(parse->ppsfd, I_PUSH, (caddr_t)m1) == -1 &&
1762: ioctl(parse->ppsfd, I_PUSH, (caddr_t)m2) == -1)
1763: {
1764: if (errno != EINVAL)
1765: {
1766: msyslog(LOG_ERR, "PARSE receiver #%d: ppsclock_init: ioctl(fd, I_PUSH, \"ppsclock\"): %m",
1767: CLK_UNIT(parse->peer));
1768: }
1769: return 0;
1770: }
1771: if (!local_init(parse))
1772: {
1773: (void)ioctl(parse->ppsfd, I_POP, (caddr_t)0);
1774: return 0;
1775: }
1776:
1777: parse->flags |= PARSE_PPSCLOCK;
1778: return 1;
1779: }
1780:
1781: /*--------------------------------------------------
1782: * parse STREAM init
1783: */
1784: static int
1785: stream_init(
1786: struct parseunit *parse
1787: )
1788: {
1789: static char m1[] = "parse";
1790: /*
1791: * now push the parse streams module
1792: * to test whether it is there (neat interface 8-( )
1793: */
1794: if (ioctl(parse->generic->io.fd, I_PUSH, (caddr_t)m1) == -1)
1795: {
1796: if (errno != EINVAL) /* accept non-existence */
1797: {
1798: msyslog(LOG_ERR, "PARSE receiver #%d: stream_init: ioctl(fd, I_PUSH, \"parse\"): %m", CLK_UNIT(parse->peer));
1799: }
1800: return 0;
1801: }
1802: else
1803: {
1804: while(ioctl(parse->generic->io.fd, I_POP, (caddr_t)0) == 0)
1805: /* empty loop */;
1806:
1807: /*
1808: * now push it a second time after we have removed all
1809: * module garbage
1810: */
1811: if (ioctl(parse->generic->io.fd, I_PUSH, (caddr_t)m1) == -1)
1812: {
1813: msyslog(LOG_ERR, "PARSE receiver #%d: stream_init: ioctl(fd, I_PUSH, \"parse\"): %m", CLK_UNIT(parse->peer));
1814: return 0;
1815: }
1816: else
1817: {
1818: return 1;
1819: }
1820: }
1821: }
1822:
1823: /*--------------------------------------------------
1824: * parse STREAM end
1825: */
1826: static void
1827: stream_end(
1828: struct parseunit *parse
1829: )
1830: {
1831: while(ioctl(parse->generic->io.fd, I_POP, (caddr_t)0) == 0)
1832: /* empty loop */;
1833: }
1834:
1835: /*--------------------------------------------------
1836: * STREAM setcs
1837: */
1838: static int
1839: stream_setcs(
1840: struct parseunit *parse,
1841: parsectl_t *tcl
1842: )
1843: {
1844: struct strioctl strioc;
1845:
1846: strioc.ic_cmd = PARSEIOC_SETCS;
1847: strioc.ic_timout = 0;
1848: strioc.ic_dp = (char *)tcl;
1849: strioc.ic_len = sizeof (*tcl);
1850:
1851: if (ioctl(parse->generic->io.fd, I_STR, (caddr_t)&strioc) == -1)
1852: {
1853: msyslog(LOG_ERR, "PARSE receiver #%d: stream_setcs: ioctl(fd, I_STR, PARSEIOC_SETCS): %m", CLK_UNIT(parse->peer));
1854: return 0;
1855: }
1856: return 1;
1857: }
1858:
1859: /*--------------------------------------------------
1860: * STREAM enable
1861: */
1862: static int
1863: stream_enable(
1864: struct parseunit *parse
1865: )
1866: {
1867: struct strioctl strioc;
1868:
1869: strioc.ic_cmd = PARSEIOC_ENABLE;
1870: strioc.ic_timout = 0;
1871: strioc.ic_dp = (char *)0;
1872: strioc.ic_len = 0;
1873:
1874: if (ioctl(parse->generic->io.fd, I_STR, (caddr_t)&strioc) == -1)
1875: {
1876: msyslog(LOG_ERR, "PARSE receiver #%d: stream_enable: ioctl(fd, I_STR, PARSEIOC_ENABLE): %m", CLK_UNIT(parse->peer));
1877: return 0;
1878: }
1879: parse->generic->io.clock_recv = stream_receive; /* ok - parse input in kernel */
1880: return 1;
1881: }
1882:
1883: /*--------------------------------------------------
1884: * STREAM disable
1885: */
1886: static int
1887: stream_disable(
1888: struct parseunit *parse
1889: )
1890: {
1891: struct strioctl strioc;
1892:
1893: strioc.ic_cmd = PARSEIOC_DISABLE;
1894: strioc.ic_timout = 0;
1895: strioc.ic_dp = (char *)0;
1896: strioc.ic_len = 0;
1897:
1898: if (ioctl(parse->generic->io.fd, I_STR, (caddr_t)&strioc) == -1)
1899: {
1900: msyslog(LOG_ERR, "PARSE receiver #%d: stream_disable: ioctl(fd, I_STR, PARSEIOC_DISABLE): %m", CLK_UNIT(parse->peer));
1901: return 0;
1902: }
1903: parse->generic->io.clock_recv = local_receive; /* ok - parse input in daemon */
1904: return 1;
1905: }
1906:
1907: /*--------------------------------------------------
1908: * STREAM getfmt
1909: */
1910: static int
1911: stream_getfmt(
1912: struct parseunit *parse,
1913: parsectl_t *tcl
1914: )
1915: {
1916: struct strioctl strioc;
1917:
1918: strioc.ic_cmd = PARSEIOC_GETFMT;
1919: strioc.ic_timout = 0;
1920: strioc.ic_dp = (char *)tcl;
1921: strioc.ic_len = sizeof (*tcl);
1922: if (ioctl(parse->generic->io.fd, I_STR, (caddr_t)&strioc) == -1)
1923: {
1924: msyslog(LOG_ERR, "PARSE receiver #%d: ioctl(fd, I_STR, PARSEIOC_GETFMT): %m", CLK_UNIT(parse->peer));
1925: return 0;
1926: }
1927: return 1;
1928: }
1929:
1930: /*--------------------------------------------------
1931: * STREAM setfmt
1932: */
1933: static int
1934: stream_setfmt(
1935: struct parseunit *parse,
1936: parsectl_t *tcl
1937: )
1938: {
1939: struct strioctl strioc;
1940:
1941: strioc.ic_cmd = PARSEIOC_SETFMT;
1942: strioc.ic_timout = 0;
1943: strioc.ic_dp = (char *)tcl;
1944: strioc.ic_len = sizeof (*tcl);
1945:
1946: if (ioctl(parse->generic->io.fd, I_STR, (caddr_t)&strioc) == -1)
1947: {
1948: msyslog(LOG_ERR, "PARSE receiver #%d: stream_setfmt: ioctl(fd, I_STR, PARSEIOC_SETFMT): %m", CLK_UNIT(parse->peer));
1949: return 0;
1950: }
1951: return 1;
1952: }
1953:
1954:
1955: /*--------------------------------------------------
1956: * STREAM timecode
1957: */
1958: static int
1959: stream_timecode(
1960: struct parseunit *parse,
1961: parsectl_t *tcl
1962: )
1963: {
1964: struct strioctl strioc;
1965:
1966: strioc.ic_cmd = PARSEIOC_TIMECODE;
1967: strioc.ic_timout = 0;
1968: strioc.ic_dp = (char *)tcl;
1969: strioc.ic_len = sizeof (*tcl);
1970:
1971: if (ioctl(parse->generic->io.fd, I_STR, (caddr_t)&strioc) == -1)
1972: {
1973: ERR(ERR_INTERNAL)
1974: msyslog(LOG_ERR, "PARSE receiver #%d: stream_timecode: ioctl(fd, I_STR, PARSEIOC_TIMECODE): %m", CLK_UNIT(parse->peer));
1975: return 0;
1976: }
1977: clear_err(parse, ERR_INTERNAL);
1978: return 1;
1979: }
1980:
1981: /*--------------------------------------------------
1982: * STREAM receive
1983: */
1984: static void
1985: stream_receive(
1986: struct recvbuf *rbufp
1987: )
1988: {
1989: struct parseunit *parse = (struct parseunit *)((void *)rbufp->recv_srcclock);
1990: parsetime_t parsetime;
1991:
1992: if (!parse->peer)
1993: return;
1994:
1995: if (rbufp->recv_length != sizeof(parsetime_t))
1996: {
1997: ERR(ERR_BADIO)
1998: msyslog(LOG_ERR,"PARSE receiver #%d: stream_receive: bad size (got %d expected %d)",
1999: CLK_UNIT(parse->peer), rbufp->recv_length, (int)sizeof(parsetime_t));
2000: parse_event(parse, CEVNT_BADREPLY);
2001: return;
2002: }
2003: clear_err(parse, ERR_BADIO);
2004:
2005: memmove((caddr_t)&parsetime,
2006: (caddr_t)rbufp->recv_buffer,
2007: sizeof(parsetime_t));
2008:
2009: #ifdef DEBUG
2010: if (debug > 3)
2011: {
2012: printf("PARSE receiver #%d: status %06x, state %08x, time %lx.%08lx, stime %lx.%08lx, ptime %lx.%08lx\n",
2013: CLK_UNIT(parse->peer),
2014: (unsigned int)parsetime.parse_status,
2015: (unsigned int)parsetime.parse_state,
2016: (unsigned long)parsetime.parse_time.tv.tv_sec,
2017: (unsigned long)parsetime.parse_time.tv.tv_usec,
2018: (unsigned long)parsetime.parse_stime.tv.tv_sec,
2019: (unsigned long)parsetime.parse_stime.tv.tv_usec,
2020: (unsigned long)parsetime.parse_ptime.tv.tv_sec,
2021: (unsigned long)parsetime.parse_ptime.tv.tv_usec);
2022: }
2023: #endif
2024:
2025: /*
2026: * switch time stamp world - be sure to normalize small usec field
2027: * errors.
2028: */
2029:
2030: cvt_ts(parsetime.parse_stime, "parse_stime");
2031:
2032: if (PARSE_TIMECODE(parsetime.parse_state))
2033: {
2034: cvt_ts(parsetime.parse_time, "parse_time");
2035: }
2036:
2037: if (PARSE_PPS(parsetime.parse_state))
2038: cvt_ts(parsetime.parse_ptime, "parse_ptime");
2039:
2040: parse_process(parse, &parsetime);
2041: }
2042: #endif
2043:
2044: /*--------------------------------------------------
2045: * local init
2046: */
2047: static int
2048: local_init(
2049: struct parseunit *parse
2050: )
2051: {
2052: return parse_ioinit(&parse->parseio);
2053: }
2054:
2055: /*--------------------------------------------------
2056: * local end
2057: */
2058: static void
2059: local_end(
2060: struct parseunit *parse
2061: )
2062: {
2063: parse_ioend(&parse->parseio);
2064: }
2065:
2066:
2067: /*--------------------------------------------------
2068: * local nop
2069: */
2070: static int
2071: local_nop(
2072: struct parseunit *parse
2073: )
2074: {
2075: return 1;
2076: }
2077:
2078: /*--------------------------------------------------
2079: * local setcs
2080: */
2081: static int
2082: local_setcs(
2083: struct parseunit *parse,
2084: parsectl_t *tcl
2085: )
2086: {
2087: return parse_setcs(tcl, &parse->parseio);
2088: }
2089:
2090: /*--------------------------------------------------
2091: * local getfmt
2092: */
2093: static int
2094: local_getfmt(
2095: struct parseunit *parse,
2096: parsectl_t *tcl
2097: )
2098: {
2099: return parse_getfmt(tcl, &parse->parseio);
2100: }
2101:
2102: /*--------------------------------------------------
2103: * local setfmt
2104: */
2105: static int
2106: local_setfmt(
2107: struct parseunit *parse,
2108: parsectl_t *tcl
2109: )
2110: {
2111: return parse_setfmt(tcl, &parse->parseio);
2112: }
2113:
2114: /*--------------------------------------------------
2115: * local timecode
2116: */
2117: static int
2118: local_timecode(
2119: struct parseunit *parse,
2120: parsectl_t *tcl
2121: )
2122: {
2123: return parse_timecode(tcl, &parse->parseio);
2124: }
2125:
2126:
2127: /*--------------------------------------------------
2128: * local input
2129: */
2130: static int
2131: local_input(
2132: struct recvbuf *rbufp
2133: )
2134: {
2135: struct parseunit *parse = (struct parseunit *)((void *)rbufp->recv_srcclock);
2136: int count;
2137: unsigned char *s;
2138: timestamp_t ts;
2139:
2140: if (!parse->peer)
2141: return 0;
2142:
2143: /*
2144: * eat all characters, parsing then and feeding complete samples
2145: */
2146: count = rbufp->recv_length;
2147: s = (unsigned char *)rbufp->recv_buffer;
2148: ts.fp = rbufp->recv_time;
2149:
2150: while (count--)
2151: {
2152: if (parse_ioread(&parse->parseio, (unsigned int)(*s++), &ts))
2153: {
2154: struct recvbuf *buf;
2155:
2156: /*
2157: * got something good to eat
2158: */
2159: if (!PARSE_PPS(parse->parseio.parse_dtime.parse_state))
2160: {
2161: #ifdef HAVE_PPSAPI
2162: if (parse->flags & PARSE_PPSCLOCK)
2163: {
2164: struct timespec pps_timeout;
2165: pps_info_t pps_info;
2166:
2167: pps_timeout.tv_sec = 0;
2168: pps_timeout.tv_nsec = 0;
2169:
2170: if (time_pps_fetch(parse->atom.handle, PPS_TSFMT_TSPEC, &pps_info,
2171: &pps_timeout) == 0)
2172: {
2173: if (pps_info.assert_sequence + pps_info.clear_sequence != parse->ppsserial)
2174: {
2175: double dtemp;
2176:
2177: struct timespec pts;
2178: /*
2179: * add PPS time stamp if available via ppsclock module
2180: * and not supplied already.
2181: */
2182: if (parse->flags & PARSE_CLEAR)
2183: pts = pps_info.clear_timestamp;
2184: else
2185: pts = pps_info.assert_timestamp;
2186:
2187: parse->parseio.parse_dtime.parse_ptime.fp.l_ui = pts.tv_sec + JAN_1970;
2188:
2189: dtemp = pts.tv_nsec / 1e9;
2190: if (dtemp < 0.) {
2191: dtemp += 1;
2192: parse->parseio.parse_dtime.parse_ptime.fp.l_ui--;
2193: }
2194: if (dtemp > 1.) {
2195: dtemp -= 1;
2196: parse->parseio.parse_dtime.parse_ptime.fp.l_ui++;
2197: }
2198: parse->parseio.parse_dtime.parse_ptime.fp.l_uf = dtemp * FRAC;
2199:
2200: parse->parseio.parse_dtime.parse_state |= PARSEB_PPS|PARSEB_S_PPS;
2201: #ifdef DEBUG
2202: if (debug > 3)
2203: {
2204: printf(
2205: "parse: local_receive: fd %d PPSAPI seq %ld - PPS %s\n",
2206: rbufp->fd,
2207: (long)pps_info.assert_sequence + (long)pps_info.clear_sequence,
2208: lfptoa(&parse->parseio.parse_dtime.parse_ptime.fp, 6));
2209: }
2210: #endif
2211: }
2212: #ifdef DEBUG
2213: else
2214: {
2215: if (debug > 3)
2216: {
2217: printf(
2218: "parse: local_receive: fd %d PPSAPI seq assert %ld, seq clear %ld - NO PPS event\n",
2219: rbufp->fd,
2220: (long)pps_info.assert_sequence, (long)pps_info.clear_sequence);
2221: }
2222: }
2223: #endif
2224: parse->ppsserial = pps_info.assert_sequence + pps_info.clear_sequence;
2225: }
2226: #ifdef DEBUG
2227: else
2228: {
2229: if (debug > 3)
2230: {
2231: printf(
2232: "parse: local_receive: fd %d PPSAPI time_pps_fetch errno = %d\n",
2233: rbufp->fd,
2234: errno);
2235: }
2236: }
2237: #endif
2238: }
2239: #else
2240: #ifdef TIOCDCDTIMESTAMP
2241: struct timeval dcd_time;
2242:
2243: if (ioctl(parse->ppsfd, TIOCDCDTIMESTAMP, &dcd_time) != -1)
2244: {
2245: l_fp tstmp;
2246:
2247: TVTOTS(&dcd_time, &tstmp);
2248: tstmp.l_ui += JAN_1970;
2249: L_SUB(&ts.fp, &tstmp);
2250: if (ts.fp.l_ui == 0)
2251: {
2252: #ifdef DEBUG
2253: if (debug)
2254: {
2255: printf(
2256: "parse: local_receive: fd %d DCDTIMESTAMP %s\n",
2257: parse->ppsfd,
2258: lfptoa(&tstmp, 6));
2259: printf(" sigio %s\n",
2260: lfptoa(&ts.fp, 6));
2261: }
2262: #endif
2263: parse->parseio.parse_dtime.parse_ptime.fp = tstmp;
2264: parse->parseio.parse_dtime.parse_state |= PARSEB_PPS|PARSEB_S_PPS;
2265: }
2266: }
2267: #else /* TIOCDCDTIMESTAMP */
2268: #if defined(HAVE_STRUCT_PPSCLOCKEV) && (defined(HAVE_CIOGETEV) || defined(HAVE_TIOCGPPSEV))
2269: if (parse->flags & PARSE_PPSCLOCK)
2270: {
2271: l_fp tts;
2272: struct ppsclockev ev;
2273:
2274: #ifdef HAVE_CIOGETEV
2275: if (ioctl(parse->ppsfd, CIOGETEV, (caddr_t)&ev) == 0)
2276: #endif
2277: #ifdef HAVE_TIOCGPPSEV
2278: if (ioctl(parse->ppsfd, TIOCGPPSEV, (caddr_t)&ev) == 0)
2279: #endif
2280: {
2281: if (ev.serial != parse->ppsserial)
2282: {
2283: /*
2284: * add PPS time stamp if available via ppsclock module
2285: * and not supplied already.
2286: */
2287: if (!buftvtots((const char *)&ev.tv, &tts))
2288: {
2289: ERR(ERR_BADDATA)
2290: msyslog(LOG_ERR,"parse: local_receive: timestamp conversion error (buftvtots) (ppsclockev.tv)");
2291: }
2292: else
2293: {
2294: parse->parseio.parse_dtime.parse_ptime.fp = tts;
2295: parse->parseio.parse_dtime.parse_state |= PARSEB_PPS|PARSEB_S_PPS;
2296: }
2297: }
2298: parse->ppsserial = ev.serial;
2299: }
2300: }
2301: #endif
2302: #endif /* TIOCDCDTIMESTAMP */
2303: #endif /* !HAVE_PPSAPI */
2304: }
2305: if (count)
2306: { /* simulate receive */
2307: buf = get_free_recv_buffer();
2308: if (buf != NULL) {
2309: memmove((caddr_t)buf->recv_buffer,
2310: (caddr_t)&parse->parseio.parse_dtime,
2311: sizeof(parsetime_t));
2312: buf->recv_length = sizeof(parsetime_t);
2313: buf->recv_time = rbufp->recv_time;
2314: buf->srcadr = rbufp->srcadr;
2315: buf->dstadr = rbufp->dstadr;
2316: buf->receiver = rbufp->receiver;
2317: buf->fd = rbufp->fd;
2318: buf->X_from_where = rbufp->X_from_where;
2319: add_full_recv_buffer(buf);
2320: }
2321: parse_iodone(&parse->parseio);
2322: }
2323: else
2324: {
2325: memmove((caddr_t)rbufp->recv_buffer,
2326: (caddr_t)&parse->parseio.parse_dtime,
2327: sizeof(parsetime_t));
2328: parse_iodone(&parse->parseio);
2329: rbufp->recv_length = sizeof(parsetime_t);
2330: return 1; /* got something & in place return */
2331: }
2332: }
2333: }
2334: return 0; /* nothing to pass up */
2335: }
2336:
2337: /*--------------------------------------------------
2338: * local receive
2339: */
2340: static void
2341: local_receive(
2342: struct recvbuf *rbufp
2343: )
2344: {
2345: struct parseunit *parse = (struct parseunit *)((void *)rbufp->recv_srcclock);
2346: parsetime_t parsetime;
2347:
2348: if (!parse->peer)
2349: return;
2350:
2351: if (rbufp->recv_length != sizeof(parsetime_t))
2352: {
2353: ERR(ERR_BADIO)
2354: msyslog(LOG_ERR,"PARSE receiver #%d: local_receive: bad size (got %d expected %d)",
2355: CLK_UNIT(parse->peer), rbufp->recv_length, (int)sizeof(parsetime_t));
2356: parse_event(parse, CEVNT_BADREPLY);
2357: return;
2358: }
2359: clear_err(parse, ERR_BADIO);
2360:
2361: memmove((caddr_t)&parsetime,
2362: (caddr_t)rbufp->recv_buffer,
2363: sizeof(parsetime_t));
2364:
2365: #ifdef DEBUG
2366: if (debug > 3)
2367: {
2368: printf("PARSE receiver #%d: status %06x, state %08x, time(fp) %lx.%08lx, stime(fp) %lx.%08lx, ptime(fp) %lx.%08lx\n",
2369: CLK_UNIT(parse->peer),
2370: (unsigned int)parsetime.parse_status,
2371: (unsigned int)parsetime.parse_state,
2372: (unsigned long)parsetime.parse_time.fp.l_ui,
2373: (unsigned long)parsetime.parse_time.fp.l_uf,
2374: (unsigned long)parsetime.parse_stime.fp.l_ui,
2375: (unsigned long)parsetime.parse_stime.fp.l_uf,
2376: (unsigned long)parsetime.parse_ptime.fp.l_ui,
2377: (unsigned long)parsetime.parse_ptime.fp.l_uf);
2378: }
2379: #endif
2380:
2381: parse_process(parse, &parsetime);
2382: }
2383:
2384: /*--------------------------------------------------
2385: * init_iobinding - find and initialize lower layers
2386: */
2387: static bind_t *
2388: init_iobinding(
2389: struct parseunit *parse
2390: )
2391: {
2392: bind_t *b = io_bindings;
2393:
2394: while (b->bd_description != (char *)0)
2395: {
2396: if ((*b->bd_init)(parse))
2397: {
2398: return b;
2399: }
2400: b++;
2401: }
2402: return (bind_t *)0;
2403: }
2404:
2405: /**===========================================================================
2406: ** support routines
2407: **/
2408:
2409: /*--------------------------------------------------
2410: * convert a flag field to a string
2411: */
2412: static char *
2413: parsestate(
2414: u_long lstate,
2415: char *buffer,
2416: int size
2417: )
2418: {
2419: static struct bits
2420: {
2421: u_long bit;
2422: const char *name;
2423: } flagstrings[] =
2424: {
2425: { PARSEB_ANNOUNCE, "DST SWITCH WARNING" },
2426: { PARSEB_POWERUP, "NOT SYNCHRONIZED" },
2427: { PARSEB_NOSYNC, "TIME CODE NOT CONFIRMED" },
2428: { PARSEB_DST, "DST" },
2429: { PARSEB_UTC, "UTC DISPLAY" },
2430: { PARSEB_LEAPADD, "LEAP ADD WARNING" },
2431: { PARSEB_LEAPDEL, "LEAP DELETE WARNING" },
2432: { PARSEB_LEAPSECOND, "LEAP SECOND" },
2433: { PARSEB_ALTERNATE, "ALTERNATE ANTENNA" },
2434: { PARSEB_TIMECODE, "TIME CODE" },
2435: { PARSEB_PPS, "PPS" },
2436: { PARSEB_POSITION, "POSITION" },
2437: { 0 }
2438: };
2439:
2440: static struct sbits
2441: {
2442: u_long bit;
2443: const char *name;
2444: } sflagstrings[] =
2445: {
2446: { PARSEB_S_LEAP, "LEAP INDICATION" },
2447: { PARSEB_S_PPS, "PPS SIGNAL" },
2448: { PARSEB_S_ANTENNA, "ANTENNA" },
2449: { PARSEB_S_POSITION, "POSITION" },
2450: { 0 }
2451: };
2452: int i;
2453: char *s, *t;
2454:
2455:
2456: *buffer = '\0';
2457: s = t = buffer;
2458:
2459: i = 0;
2460: while (flagstrings[i].bit)
2461: {
2462: if (flagstrings[i].bit & lstate)
2463: {
2464: if (s != t)
2465: strncpy(t, "; ", BUFFER_SIZES(buffer, t, size));
2466: strncat(t, flagstrings[i].name, BUFFER_SIZES(buffer, t, size));
2467: t += strlen(t);
2468: }
2469: i++;
2470: }
2471:
2472: if (lstate & (PARSEB_S_LEAP|PARSEB_S_ANTENNA|PARSEB_S_PPS|PARSEB_S_POSITION))
2473: {
2474: if (s != t)
2475: strncpy(t, "; ", BUFFER_SIZES(buffer, t, size));
2476:
2477: t += strlen(t);
2478:
2479: strncpy(t, "(", BUFFER_SIZES(buffer, t, size));
2480:
2481: s = t = t + strlen(t);
2482:
2483: i = 0;
2484: while (sflagstrings[i].bit)
2485: {
2486: if (sflagstrings[i].bit & lstate)
2487: {
2488: if (t != s)
2489: {
2490: strncpy(t, "; ", BUFFER_SIZES(buffer, t, size));
2491: t += 2;
2492: }
2493:
2494: strncpy(t, sflagstrings[i].name, BUFFER_SIZES(buffer, t, size));
2495: t += strlen(t);
2496: }
2497: i++;
2498: }
2499: strncpy(t, ")", BUFFER_SIZES(buffer, t, size));
2500: }
2501: return buffer;
2502: }
2503:
2504: /*--------------------------------------------------
2505: * convert a status flag field to a string
2506: */
2507: static char *
2508: parsestatus(
2509: u_long lstate,
2510: char *buffer,
2511: int size
2512: )
2513: {
2514: static struct bits
2515: {
2516: u_long bit;
2517: const char *name;
2518: } flagstrings[] =
2519: {
2520: { CVT_OK, "CONVERSION SUCCESSFUL" },
2521: { CVT_NONE, "NO CONVERSION" },
2522: { CVT_FAIL, "CONVERSION FAILED" },
2523: { CVT_BADFMT, "ILLEGAL FORMAT" },
2524: { CVT_BADDATE, "DATE ILLEGAL" },
2525: { CVT_BADTIME, "TIME ILLEGAL" },
2526: { CVT_ADDITIONAL, "ADDITIONAL DATA" },
2527: { 0 }
2528: };
2529: int i;
2530:
2531: *buffer = '\0';
2532:
2533: i = 0;
2534: while (flagstrings[i].bit)
2535: {
2536: if (flagstrings[i].bit & lstate)
2537: {
2538: if (buffer[0])
2539: strncat(buffer, "; ", size);
2540: strncat(buffer, flagstrings[i].name, size);
2541: }
2542: i++;
2543: }
2544:
2545: return buffer;
2546: }
2547:
2548: /*--------------------------------------------------
2549: * convert a clock status flag field to a string
2550: */
2551: static const char *
2552: clockstatus(
2553: u_long lstate
2554: )
2555: {
2556: static char buffer[20];
2557: static struct status
2558: {
2559: u_long value;
2560: const char *name;
2561: } flagstrings[] =
2562: {
2563: { CEVNT_NOMINAL, "NOMINAL" },
2564: { CEVNT_TIMEOUT, "NO RESPONSE" },
2565: { CEVNT_BADREPLY,"BAD FORMAT" },
2566: { CEVNT_FAULT, "FAULT" },
2567: { CEVNT_PROP, "PROPAGATION DELAY" },
2568: { CEVNT_BADDATE, "ILLEGAL DATE" },
2569: { CEVNT_BADTIME, "ILLEGAL TIME" },
2570: { (unsigned)~0L }
2571: };
2572: int i;
2573:
2574: i = 0;
2575: while (flagstrings[i].value != ~0)
2576: {
2577: if (flagstrings[i].value == lstate)
2578: {
2579: return flagstrings[i].name;
2580: }
2581: i++;
2582: }
2583:
2584: snprintf(buffer, sizeof(buffer), "unknown #%ld", (u_long)lstate);
2585:
2586: return buffer;
2587: }
2588:
2589:
2590: /*--------------------------------------------------
2591: * l_mktime - make representation of a relative time
2592: */
2593: static char *
2594: l_mktime(
2595: u_long delta
2596: )
2597: {
2598: u_long tmp, m, s;
2599: static char buffer[40];
2600: char *t;
2601:
2602: buffer[0] = '\0';
2603:
2604: if ((tmp = delta / (60*60*24)) != 0)
2605: {
2606: snprintf(buffer, BUFFER_SIZE(buffer, buffer), "%ldd+", (u_long)tmp);
2607: delta -= tmp * 60*60*24;
2608: }
2609:
2610: s = delta % 60;
2611: delta /= 60;
2612: m = delta % 60;
2613: delta /= 60;
2614:
2615: t = buffer + strlen(buffer);
2616:
2617: snprintf(t, BUFFER_SIZE(buffer, t), "%02d:%02d:%02d",
2618: (int)delta, (int)m, (int)s);
2619:
2620: return buffer;
2621: }
2622:
2623:
2624: /*--------------------------------------------------
2625: * parse_statistics - list summary of clock states
2626: */
2627: static void
2628: parse_statistics(
2629: struct parseunit *parse
2630: )
2631: {
2632: int i;
2633:
2634: NLOG(NLOG_CLOCKSTATIST) /* conditional if clause for conditional syslog */
2635: {
2636: msyslog(LOG_INFO, "PARSE receiver #%d: running time: %s",
2637: CLK_UNIT(parse->peer),
2638: l_mktime(current_time - parse->generic->timestarted));
2639:
2640: msyslog(LOG_INFO, "PARSE receiver #%d: current status: %s",
2641: CLK_UNIT(parse->peer),
2642: clockstatus(parse->generic->currentstatus));
2643:
2644: for (i = 0; i <= CEVNT_MAX; i++)
2645: {
2646: u_long s_time;
2647: u_long percent, d = current_time - parse->generic->timestarted;
2648:
2649: percent = s_time = PARSE_STATETIME(parse, i);
2650:
2651: while (((u_long)(~0) / 10000) < percent)
2652: {
2653: percent /= 10;
2654: d /= 10;
2655: }
2656:
2657: if (d)
2658: percent = (percent * 10000) / d;
2659: else
2660: percent = 10000;
2661:
2662: if (s_time)
2663: msyslog(LOG_INFO, "PARSE receiver #%d: state %18s: %13s (%3ld.%02ld%%)",
2664: CLK_UNIT(parse->peer),
2665: clockstatus((unsigned int)i),
2666: l_mktime(s_time),
2667: percent / 100, percent % 100);
2668: }
2669: }
2670: }
2671:
2672: /*--------------------------------------------------
2673: * cparse_statistics - wrapper for statistics call
2674: */
2675: static void
2676: cparse_statistics(
2677: struct parseunit *parse
2678: )
2679: {
2680: if (parse->laststatistic + PARSESTATISTICS < current_time)
2681: parse_statistics(parse);
2682: parse->laststatistic = current_time;
2683: }
2684:
2685: /**===========================================================================
2686: ** ntp interface routines
2687: **/
2688:
2689: /*--------------------------------------------------
2690: * parse_shutdown - shut down a PARSE clock
2691: */
2692: static void
2693: parse_shutdown(
2694: int unit,
2695: struct peer *peer
2696: )
2697: {
2698: struct parseunit *parse = (struct parseunit *)0;
2699:
2700: if (peer && peer->procptr)
2701: parse = (struct parseunit *)peer->procptr->unitptr;
2702:
2703: if (!parse)
2704: {
2705: /* nothing to clean up */
2706: return;
2707: }
2708:
2709: if (!parse->peer)
2710: {
2711: msyslog(LOG_INFO, "PARSE receiver #%d: INTERNAL ERROR - unit already inactive - shutdown ignored", unit);
2712: return;
2713: }
2714:
2715: #ifdef HAVE_PPSAPI
2716: if (parse->flags & PARSE_PPSCLOCK)
2717: {
2718: (void)time_pps_destroy(parse->atom.handle);
2719: }
2720: #endif
2721: if (parse->generic->io.fd != parse->ppsfd && parse->ppsfd != -1)
2722: (void)close(parse->ppsfd); /* close separate PPS source */
2723:
2724: /*
2725: * print statistics a last time and
2726: * stop statistics machine
2727: */
2728: parse_statistics(parse);
2729:
2730: if (parse->parse_type->cl_end)
2731: {
2732: parse->parse_type->cl_end(parse);
2733: }
2734:
2735: /*
2736: * cleanup before leaving this world
2737: */
2738: if (parse->binding)
2739: PARSE_END(parse);
2740:
2741: /*
2742: * Tell the I/O module to turn us off. We're history.
2743: */
2744: io_closeclock(&parse->generic->io);
2745:
2746: free_varlist(parse->kv);
2747:
2748: NLOG(NLOG_CLOCKINFO) /* conditional if clause for conditional syslog */
2749: msyslog(LOG_INFO, "PARSE receiver #%d: reference clock \"%s\" removed",
2750: CLK_UNIT(parse->peer), parse->parse_type->cl_description);
2751:
2752: parse->peer = (struct peer *)0; /* unused now */
2753: peer->procptr->unitptr = (caddr_t)0;
2754: free(parse);
2755: }
2756:
2757: #ifdef HAVE_PPSAPI
2758: /*----------------------------------------
2759: * set up HARDPPS via PPSAPI
2760: */
2761: static void
2762: parse_hardpps(
2763: struct parseunit *parse,
2764: int mode
2765: )
2766: {
2767: if (parse->hardppsstate == mode)
2768: return;
2769:
2770: if (CLK_PPS(parse->peer) && (parse->flags & PARSE_PPSKERNEL)) {
2771: int i = 0;
2772:
2773: if (mode == PARSE_HARDPPS_ENABLE)
2774: {
2775: if (parse->flags & PARSE_CLEAR)
2776: i = PPS_CAPTURECLEAR;
2777: else
2778: i = PPS_CAPTUREASSERT;
2779: }
2780:
2781: if (time_pps_kcbind(parse->atom.handle, PPS_KC_HARDPPS, i,
2782: PPS_TSFMT_TSPEC) < 0) {
2783: msyslog(LOG_ERR, "PARSE receiver #%d: time_pps_kcbind failed: %m",
2784: CLK_UNIT(parse->peer));
2785: } else {
2786: NLOG(NLOG_CLOCKINFO)
2787: msyslog(LOG_INFO, "PARSE receiver #%d: kernel PPS synchronisation %sabled",
2788: CLK_UNIT(parse->peer), (mode == PARSE_HARDPPS_ENABLE) ? "en" : "dis");
2789: /*
2790: * tell the rest, that we have a kernel PPS source, iff we ever enable HARDPPS
2791: */
2792: if (mode == PARSE_HARDPPS_ENABLE)
2793: pps_enable = 1;
2794: }
2795: }
2796:
2797: parse->hardppsstate = mode;
2798: }
2799:
2800: /*----------------------------------------
2801: * set up PPS via PPSAPI
2802: */
2803: static int
2804: parse_ppsapi(
2805: struct parseunit *parse
2806: )
2807: {
2808: int cap, mode_ppsoffset;
2809: char *cp;
2810:
2811: parse->flags &= ~PARSE_PPSCLOCK;
2812:
2813: /*
2814: * collect PPSAPI offset capability - should move into generic handling
2815: */
2816: if (time_pps_getcap(parse->atom.handle, &cap) < 0) {
2817: msyslog(LOG_ERR, "PARSE receiver #%d: parse_ppsapi: time_pps_getcap failed: %m",
2818: CLK_UNIT(parse->peer));
2819:
2820: return 0;
2821: }
2822:
2823: /*
2824: * initialize generic PPSAPI interface
2825: *
2826: * we leave out CLK_FLAG3 as time_pps_kcbind()
2827: * is handled here for now. Ideally this should also
2828: * be part of the generic PPSAPI interface
2829: */
2830: if (!refclock_params(parse->flags & (CLK_FLAG1|CLK_FLAG2|CLK_FLAG4), &parse->atom))
2831: return 0;
2832:
2833: /* nb. only turn things on, if someone else has turned something
2834: * on before we get here, leave it alone!
2835: */
2836:
2837: if (parse->flags & PARSE_CLEAR) {
2838: cp = "CLEAR";
2839: mode_ppsoffset = PPS_OFFSETCLEAR;
2840: } else {
2841: cp = "ASSERT";
2842: mode_ppsoffset = PPS_OFFSETASSERT;
2843: }
2844:
2845: msyslog(LOG_INFO, "PARSE receiver #%d: initializing PPS to %s",
2846: CLK_UNIT(parse->peer), cp);
2847:
2848: if (!(mode_ppsoffset & cap)) {
2849: msyslog(LOG_WARNING, "PARSE receiver #%d: Cannot set PPS_%sCLEAR, this will increase jitter (PPS API capabilities=0x%x)",
2850: CLK_UNIT(parse->peer), cp, cap);
2851: mode_ppsoffset = 0;
2852: } else {
2853: if (mode_ppsoffset == PPS_OFFSETCLEAR)
2854: {
2855: parse->atom.pps_params.clear_offset.tv_sec = -parse->ppsphaseadjust;
2856: parse->atom.pps_params.clear_offset.tv_nsec = -1e9*(parse->ppsphaseadjust - (long)parse->ppsphaseadjust);
2857: }
2858:
2859: if (mode_ppsoffset == PPS_OFFSETASSERT)
2860: {
2861: parse->atom.pps_params.assert_offset.tv_sec = -parse->ppsphaseadjust;
2862: parse->atom.pps_params.assert_offset.tv_nsec = -1e9*(parse->ppsphaseadjust - (long)parse->ppsphaseadjust);
2863: }
2864: }
2865:
2866: parse->atom.pps_params.mode |= mode_ppsoffset;
2867:
2868: if (time_pps_setparams(parse->atom.handle, &parse->atom.pps_params) < 0) {
2869: msyslog(LOG_ERR, "PARSE receiver #%d: FAILED set PPS parameters: %m",
2870: CLK_UNIT(parse->peer));
2871: return 0;
2872: }
2873:
2874: parse->flags |= PARSE_PPSCLOCK;
2875: return 1;
2876: }
2877: #else
2878: #define parse_hardpps(_PARSE_, _MODE_) /* empty */
2879: #endif
2880:
2881: /*--------------------------------------------------
2882: * parse_start - open the PARSE devices and initialize data for processing
2883: */
2884: static int
2885: parse_start(
2886: int sysunit,
2887: struct peer *peer
2888: )
2889: {
2890: u_int unit;
2891: int fd232;
2892: #ifdef HAVE_TERMIOS
2893: struct termios tio; /* NEEDED FOR A LONG TIME ! */
2894: #endif
2895: #ifdef HAVE_SYSV_TTYS
2896: struct termio tio; /* NEEDED FOR A LONG TIME ! */
2897: #endif
2898: struct parseunit * parse;
2899: char parsedev[sizeof(PARSEDEVICE)+20];
2900: char parseppsdev[sizeof(PARSEPPSDEVICE)+20];
2901: parsectl_t tmp_ctl;
2902: u_int type;
2903:
2904: /*
2905: * get out Copyright information once
2906: */
2907: if (!notice)
2908: {
2909: NLOG(NLOG_CLOCKINFO) /* conditional if clause for conditional syslog */
2910: msyslog(LOG_INFO, "NTP PARSE support: Copyright (c) 1989-2009, Frank Kardel");
2911: notice = 1;
2912: }
2913:
2914: type = CLK_TYPE(peer);
2915: unit = CLK_UNIT(peer);
2916:
2917: if ((type == ~0) || (parse_clockinfo[type].cl_description == (char *)0))
2918: {
2919: msyslog(LOG_ERR, "PARSE receiver #%d: parse_start: unsupported clock type %d (max %d)",
2920: unit, CLK_REALTYPE(peer), ncltypes-1);
2921: return 0;
2922: }
2923:
2924: /*
2925: * Unit okay, attempt to open the device.
2926: */
2927: (void) snprintf(parsedev, sizeof(parsedev), PARSEDEVICE, unit);
2928: (void) snprintf(parseppsdev, sizeof(parsedev), PARSEPPSDEVICE, unit);
2929:
2930: #ifndef O_NOCTTY
2931: #define O_NOCTTY 0
2932: #endif
2933:
2934: fd232 = open(parsedev, O_RDWR | O_NOCTTY
2935: #ifdef O_NONBLOCK
2936: | O_NONBLOCK
2937: #endif
2938: , 0777);
2939:
2940: if (fd232 == -1)
2941: {
2942: msyslog(LOG_ERR, "PARSE receiver #%d: parse_start: open of %s failed: %m", unit, parsedev);
2943: return 0;
2944: }
2945:
2946: parse = (struct parseunit *)emalloc(sizeof(struct parseunit));
2947:
2948: memset((char *)parse, 0, sizeof(struct parseunit));
2949:
2950: parse->generic = peer->procptr; /* link up */
2951: parse->generic->unitptr = (caddr_t)parse; /* link down */
2952:
2953: /*
2954: * Set up the structures
2955: */
2956: parse->generic->timestarted = current_time;
2957: parse->lastchange = current_time;
2958:
2959: parse->flags = 0;
2960: parse->pollneeddata = 0;
2961: parse->laststatistic = current_time;
2962: parse->lastformat = (unsigned short)~0; /* assume no format known */
2963: parse->timedata.parse_status = (unsigned short)~0; /* be sure to mark initial status change */
2964: parse->lastmissed = 0; /* assume got everything */
2965: parse->ppsserial = 0;
2966: parse->ppsfd = -1;
2967: parse->localdata = (void *)0;
2968: parse->localstate = 0;
2969: parse->kv = (struct ctl_var *)0;
2970:
2971: clear_err(parse, ERR_ALL);
2972:
2973: parse->parse_type = &parse_clockinfo[type];
2974:
2975: parse->maxunsync = parse->parse_type->cl_maxunsync;
2976:
2977: parse->generic->fudgetime1 = parse->parse_type->cl_basedelay;
2978:
2979: parse->generic->fudgetime2 = 0.0;
2980: parse->ppsphaseadjust = parse->generic->fudgetime2;
2981:
2982: parse->generic->clockdesc = parse->parse_type->cl_description;
2983:
2984: peer->rootdelay = parse->parse_type->cl_rootdelay;
2985: peer->sstclktype = parse->parse_type->cl_type;
2986: peer->precision = sys_precision;
2987:
2988: peer->stratum = STRATUM_REFCLOCK;
2989:
2990: if (peer->stratum <= 1)
2991: memmove((char *)&parse->generic->refid, parse->parse_type->cl_id, 4);
2992: else
2993: parse->generic->refid = htonl(PARSEHSREFID);
2994:
2995: parse->generic->io.fd = fd232;
2996:
2997: parse->peer = peer; /* marks it also as busy */
2998:
2999: /*
3000: * configure terminal line
3001: */
3002: if (TTY_GETATTR(fd232, &tio) == -1)
3003: {
3004: msyslog(LOG_ERR, "PARSE receiver #%d: parse_start: tcgetattr(%d, &tio): %m", unit, fd232);
3005: parse_shutdown(CLK_UNIT(parse->peer), peer); /* let our cleaning staff do the work */
3006: return 0;
3007: }
3008: else
3009: {
3010: #ifndef _PC_VDISABLE
3011: memset((char *)tio.c_cc, 0, sizeof(tio.c_cc));
3012: #else
3013: int disablec;
3014: errno = 0; /* pathconf can deliver -1 without changing errno ! */
3015:
3016: disablec = fpathconf(parse->generic->io.fd, _PC_VDISABLE);
3017: if (disablec == -1 && errno)
3018: {
3019: msyslog(LOG_ERR, "PARSE receiver #%d: parse_start: fpathconf(fd, _PC_VDISABLE): %m", CLK_UNIT(parse->peer));
3020: memset((char *)tio.c_cc, 0, sizeof(tio.c_cc)); /* best guess */
3021: }
3022: else
3023: if (disablec != -1)
3024: memset((char *)tio.c_cc, disablec, sizeof(tio.c_cc));
3025: #endif
3026:
3027: #if defined (VMIN) || defined(VTIME)
3028: if ((parse_clockinfo[type].cl_lflag & ICANON) == 0)
3029: {
3030: #ifdef VMIN
3031: tio.c_cc[VMIN] = 1;
3032: #endif
3033: #ifdef VTIME
3034: tio.c_cc[VTIME] = 0;
3035: #endif
3036: }
3037: #endif
3038:
3039: tio.c_cflag = parse_clockinfo[type].cl_cflag;
3040: tio.c_iflag = parse_clockinfo[type].cl_iflag;
3041: tio.c_oflag = parse_clockinfo[type].cl_oflag;
3042: tio.c_lflag = parse_clockinfo[type].cl_lflag;
3043:
3044:
3045: #ifdef HAVE_TERMIOS
3046: if ((cfsetospeed(&tio, parse_clockinfo[type].cl_speed) == -1) ||
3047: (cfsetispeed(&tio, parse_clockinfo[type].cl_speed) == -1))
3048: {
3049: msyslog(LOG_ERR, "PARSE receiver #%d: parse_start: tcset{i,o}speed(&tio, speed): %m", unit);
3050: parse_shutdown(CLK_UNIT(parse->peer), peer); /* let our cleaning staff do the work */
3051: return 0;
3052: }
3053: #else
3054: tio.c_cflag |= parse_clockinfo[type].cl_speed;
3055: #endif
3056:
3057: /*
3058: * set up pps device
3059: * if the PARSEPPSDEVICE can be opened that will be used
3060: * for PPS else PARSEDEVICE will be used
3061: */
3062: parse->ppsfd = open(parseppsdev, O_RDWR | O_NOCTTY
3063: #ifdef O_NONBLOCK
3064: | O_NONBLOCK
3065: #endif
3066: , 0777);
3067:
3068: if (parse->ppsfd == -1)
3069: {
3070: parse->ppsfd = fd232;
3071: }
3072:
3073: /*
3074: * Linux PPS - the old way
3075: */
3076: #if defined(HAVE_TIO_SERIAL_STUFF) /* Linux hack: define PPS interface */
3077: {
3078: struct serial_struct ss;
3079: if (ioctl(parse->ppsfd, TIOCGSERIAL, &ss) < 0 ||
3080: (
3081: #ifdef ASYNC_LOW_LATENCY
3082: ss.flags |= ASYNC_LOW_LATENCY,
3083: #endif
3084: #ifndef HAVE_PPSAPI
3085: #ifdef ASYNC_PPS_CD_NEG
3086: ss.flags |= ASYNC_PPS_CD_NEG,
3087: #endif
3088: #endif
3089: ioctl(parse->ppsfd, TIOCSSERIAL, &ss)) < 0) {
3090: msyslog(LOG_NOTICE, "refclock_parse: TIOCSSERIAL fd %d, %m", parse->ppsfd);
3091: msyslog(LOG_NOTICE,
3092: "refclock_parse: optional PPS processing not available");
3093: } else {
3094: parse->flags |= PARSE_PPSCLOCK;
3095: #ifdef ASYNC_PPS_CD_NEG
3096: NLOG(NLOG_CLOCKINFO)
3097: msyslog(LOG_INFO,
3098: "refclock_parse: PPS detection on");
3099: #endif
3100: }
3101: }
3102: #endif
3103:
3104: /*
3105: * SUN the Solaris way
3106: */
3107: #ifdef HAVE_TIOCSPPS /* SUN PPS support */
3108: if (CLK_PPS(parse->peer))
3109: {
3110: int i = 1;
3111:
3112: if (ioctl(parse->ppsfd, TIOCSPPS, (caddr_t)&i) == 0)
3113: {
3114: parse->flags |= PARSE_PPSCLOCK;
3115: }
3116: }
3117: #endif
3118:
3119: /*
3120: * PPS via PPSAPI
3121: */
3122: #if defined(HAVE_PPSAPI)
3123: parse->hardppsstate = PARSE_HARDPPS_DISABLE;
3124: if (CLK_PPS(parse->peer))
3125: {
3126: if (!refclock_ppsapi(parse->ppsfd, &parse->atom))
3127: {
3128: msyslog(LOG_NOTICE, "PARSE receiver #%d: parse_start: could not set up PPS: %m", CLK_UNIT(parse->peer));
3129: }
3130: else
3131: {
3132: parse_ppsapi(parse);
3133: }
3134: }
3135: #endif
3136:
3137: if (TTY_SETATTR(fd232, &tio) == -1)
3138: {
3139: msyslog(LOG_ERR, "PARSE receiver #%d: parse_start: tcsetattr(%d, &tio): %m", unit, fd232);
3140: parse_shutdown(CLK_UNIT(parse->peer), peer); /* let our cleaning staff do the work */
3141: return 0;
3142: }
3143: }
3144:
3145: /*
3146: * pick correct input machine
3147: */
3148: parse->generic->io.srcclock = (caddr_t)parse;
3149: parse->generic->io.datalen = 0;
3150:
3151: parse->binding = init_iobinding(parse);
3152:
3153: if (parse->binding == (bind_t *)0)
3154: {
3155: msyslog(LOG_ERR, "PARSE receiver #%d: parse_start: io sub system initialisation failed.", CLK_UNIT(parse->peer));
3156: parse_shutdown(CLK_UNIT(parse->peer), peer); /* let our cleaning staff do the work */
3157: return 0; /* well, ok - special initialisation broke */
3158: }
3159:
3160: parse->generic->io.clock_recv = parse->binding->bd_receive; /* pick correct receive routine */
3161: parse->generic->io.io_input = parse->binding->bd_io_input; /* pick correct input routine */
3162:
3163: /*
3164: * as we always(?) get 8 bit chars we want to be
3165: * sure, that the upper bits are zero for less
3166: * than 8 bit I/O - so we pass that information on.
3167: * note that there can be only one bit count format
3168: * per file descriptor
3169: */
3170:
3171: switch (tio.c_cflag & CSIZE)
3172: {
3173: case CS5:
3174: tmp_ctl.parsesetcs.parse_cs = PARSE_IO_CS5;
3175: break;
3176:
3177: case CS6:
3178: tmp_ctl.parsesetcs.parse_cs = PARSE_IO_CS6;
3179: break;
3180:
3181: case CS7:
3182: tmp_ctl.parsesetcs.parse_cs = PARSE_IO_CS7;
3183: break;
3184:
3185: case CS8:
3186: tmp_ctl.parsesetcs.parse_cs = PARSE_IO_CS8;
3187: break;
3188: }
3189:
3190: if (!PARSE_SETCS(parse, &tmp_ctl))
3191: {
3192: msyslog(LOG_ERR, "PARSE receiver #%d: parse_start: parse_setcs() FAILED.", unit);
3193: parse_shutdown(CLK_UNIT(parse->peer), peer); /* let our cleaning staff do the work */
3194: return 0; /* well, ok - special initialisation broke */
3195: }
3196:
3197: strncpy(tmp_ctl.parseformat.parse_buffer, parse->parse_type->cl_format, sizeof(tmp_ctl.parseformat.parse_buffer));
3198: tmp_ctl.parseformat.parse_count = strlen(tmp_ctl.parseformat.parse_buffer);
3199:
3200: if (!PARSE_SETFMT(parse, &tmp_ctl))
3201: {
3202: msyslog(LOG_ERR, "PARSE receiver #%d: parse_start: parse_setfmt() FAILED.", unit);
3203: parse_shutdown(CLK_UNIT(parse->peer), peer); /* let our cleaning staff do the work */
3204: return 0; /* well, ok - special initialisation broke */
3205: }
3206:
3207: /*
3208: * get rid of all IO accumulated so far
3209: */
3210: #ifdef HAVE_TERMIOS
3211: (void) tcflush(parse->generic->io.fd, TCIOFLUSH);
3212: #else
3213: #if defined(TCFLSH) && defined(TCIOFLUSH)
3214: {
3215: int flshcmd = TCIOFLUSH;
3216:
3217: (void) ioctl(parse->generic->io.fd, TCFLSH, (caddr_t)&flshcmd);
3218: }
3219: #endif
3220: #endif
3221:
3222: /*
3223: * try to do any special initializations
3224: */
3225: if (parse->parse_type->cl_init)
3226: {
3227: if (parse->parse_type->cl_init(parse))
3228: {
3229: parse_shutdown(CLK_UNIT(parse->peer), peer); /* let our cleaning staff do the work */
3230: return 0; /* well, ok - special initialisation broke */
3231: }
3232: }
3233:
3234: /*
3235: * Insert in async io device list.
3236: */
3237: if (!io_addclock(&parse->generic->io))
3238: {
3239: msyslog(LOG_ERR,
3240: "PARSE receiver #%d: parse_start: addclock %s fails (ABORT - clock type requires async io)", CLK_UNIT(parse->peer), parsedev);
3241: parse_shutdown(CLK_UNIT(parse->peer), peer); /* let our cleaning staff do the work */
3242: return 0;
3243: }
3244:
3245: /*
3246: * print out configuration
3247: */
3248: NLOG(NLOG_CLOCKINFO)
3249: {
3250: /* conditional if clause for conditional syslog */
3251: msyslog(LOG_INFO, "PARSE receiver #%d: reference clock \"%s\" (I/O device %s, PPS device %s) added",
3252: CLK_UNIT(parse->peer),
3253: parse->parse_type->cl_description, parsedev,
3254: (parse->ppsfd != parse->generic->io.fd) ? parseppsdev : parsedev);
3255:
3256: msyslog(LOG_INFO, "PARSE receiver #%d: Stratum %d, trust time %s, precision %d",
3257: CLK_UNIT(parse->peer),
3258: parse->peer->stratum,
3259: l_mktime(parse->maxunsync), parse->peer->precision);
3260:
3261: msyslog(LOG_INFO, "PARSE receiver #%d: rootdelay %.6f s, phase adjustment %.6f s, PPS phase adjustment %.6f s, %s IO handling",
3262: CLK_UNIT(parse->peer),
3263: parse->parse_type->cl_rootdelay,
3264: parse->generic->fudgetime1,
3265: parse->ppsphaseadjust,
3266: parse->binding->bd_description);
3267:
3268: msyslog(LOG_INFO, "PARSE receiver #%d: Format recognition: %s", CLK_UNIT(parse->peer),
3269: parse->parse_type->cl_format);
3270: msyslog(LOG_INFO, "PARSE receiver #%d: %sPPS support%s", CLK_UNIT(parse->peer),
3271: CLK_PPS(parse->peer) ? "" : "NO ",
3272: CLK_PPS(parse->peer) ?
3273: #ifdef PPS_METHOD
3274: " (implementation " PPS_METHOD ")"
3275: #else
3276: ""
3277: #endif
3278: : ""
3279: );
3280: }
3281:
3282: return 1;
3283: }
3284:
3285: /*--------------------------------------------------
3286: * parse_ctl - process changes on flags/time values
3287: */
3288: static void
3289: parse_ctl(
3290: struct parseunit *parse,
3291: struct refclockstat *in
3292: )
3293: {
3294: if (in)
3295: {
3296: if (in->haveflags & (CLK_HAVEFLAG1|CLK_HAVEFLAG2|CLK_HAVEFLAG3|CLK_HAVEFLAG4))
3297: {
3298: parse->flags = (parse->flags & ~(CLK_FLAG1|CLK_FLAG2|CLK_FLAG3|CLK_FLAG4)) |
3299: (in->flags & (CLK_FLAG1|CLK_FLAG2|CLK_FLAG3|CLK_FLAG4));
3300: #if defined(HAVE_PPSAPI)
3301: if (CLK_PPS(parse->peer))
3302: {
3303: parse_ppsapi(parse);
3304: }
3305: #endif
3306: }
3307:
3308: if (in->haveflags & CLK_HAVETIME1)
3309: {
3310: parse->generic->fudgetime1 = in->fudgetime1;
3311: msyslog(LOG_INFO, "PARSE receiver #%d: new phase adjustment %.6f s",
3312: CLK_UNIT(parse->peer),
3313: parse->generic->fudgetime1);
3314: }
3315:
3316: if (in->haveflags & CLK_HAVETIME2)
3317: {
3318: parse->generic->fudgetime2 = in->fudgetime2;
3319: if (parse->flags & PARSE_TRUSTTIME)
3320: {
3321: parse->maxunsync = (u_long)ABS(in->fudgetime2);
3322: msyslog(LOG_INFO, "PARSE receiver #%d: new trust time %s",
3323: CLK_UNIT(parse->peer),
3324: l_mktime(parse->maxunsync));
3325: }
3326: else
3327: {
3328: parse->ppsphaseadjust = in->fudgetime2;
3329: msyslog(LOG_INFO, "PARSE receiver #%d: new PPS phase adjustment %.6f s",
3330: CLK_UNIT(parse->peer),
3331: parse->ppsphaseadjust);
3332: #if defined(HAVE_PPSAPI)
3333: if (CLK_PPS(parse->peer))
3334: {
3335: parse_ppsapi(parse);
3336: }
3337: #endif
3338: }
3339: }
3340: }
3341: }
3342:
3343: /*--------------------------------------------------
3344: * parse_poll - called by the transmit procedure
3345: */
3346: static void
3347: parse_poll(
3348: int unit,
3349: struct peer *peer
3350: )
3351: {
3352: struct parseunit *parse = (struct parseunit *)peer->procptr->unitptr;
3353:
3354: if (peer != parse->peer)
3355: {
3356: msyslog(LOG_ERR,
3357: "PARSE receiver #%d: poll: INTERNAL: peer incorrect",
3358: unit);
3359: return;
3360: }
3361:
3362: /*
3363: * Update clock stat counters
3364: */
3365: parse->generic->polls++;
3366:
3367: if (parse->pollneeddata &&
3368: ((current_time - parse->pollneeddata) > (1<<(max(min(parse->peer->hpoll, parse->peer->ppoll), parse->peer->minpoll)))))
3369: {
3370: /*
3371: * start worrying when exceeding a poll inteval
3372: * bad news - didn't get a response last time
3373: */
3374: parse->lastmissed = current_time;
3375: parse_event(parse, CEVNT_TIMEOUT);
3376:
3377: ERR(ERR_NODATA)
3378: msyslog(LOG_WARNING, "PARSE receiver #%d: no data from device within poll interval (check receiver / wiring)", CLK_UNIT(parse->peer));
3379: }
3380:
3381: /*
3382: * we just mark that we want the next sample for the clock filter
3383: */
3384: parse->pollneeddata = current_time;
3385:
3386: if (parse->parse_type->cl_poll)
3387: {
3388: parse->parse_type->cl_poll(parse);
3389: }
3390:
3391: cparse_statistics(parse);
3392:
3393: return;
3394: }
3395:
3396: #define LEN_STATES 300 /* length of state string */
3397:
3398: /*--------------------------------------------------
3399: * parse_control - set fudge factors, return statistics
3400: */
3401: static void
3402: parse_control(
3403: int unit,
3404: struct refclockstat *in,
3405: struct refclockstat *out,
3406: struct peer *peer
3407: )
3408: {
3409: struct parseunit *parse = (struct parseunit *)peer->procptr->unitptr;
3410: parsectl_t tmpctl;
3411:
3412: static char outstatus[400]; /* status output buffer */
3413:
3414: if (out)
3415: {
3416: out->lencode = 0;
3417: out->p_lastcode = 0;
3418: out->kv_list = (struct ctl_var *)0;
3419: }
3420:
3421: if (!parse || !parse->peer)
3422: {
3423: msyslog(LOG_ERR, "PARSE receiver #%d: parse_control: unit invalid (UNIT INACTIVE)",
3424: unit);
3425: return;
3426: }
3427:
3428: unit = CLK_UNIT(parse->peer);
3429:
3430: /*
3431: * handle changes
3432: */
3433: parse_ctl(parse, in);
3434:
3435: /*
3436: * supply data
3437: */
3438: if (out)
3439: {
3440: u_long sum = 0;
3441: char *tt, *start;
3442: int i;
3443:
3444: outstatus[0] = '\0';
3445:
3446: out->type = REFCLK_PARSE;
3447:
3448: /*
3449: * keep fudgetime2 in sync with TRUSTTIME/MAXUNSYNC flag1
3450: */
3451: parse->generic->fudgetime2 = (parse->flags & PARSE_TRUSTTIME) ? (double)parse->maxunsync : parse->ppsphaseadjust;
3452:
3453: /*
3454: * figure out skew between PPS and RS232 - just for informational
3455: * purposes
3456: */
3457: if (PARSE_SYNC(parse->timedata.parse_state))
3458: {
3459: if (PARSE_PPS(parse->timedata.parse_state) && PARSE_TIMECODE(parse->timedata.parse_state))
3460: {
3461: l_fp off;
3462:
3463: /*
3464: * we have a PPS and RS232 signal - calculate the skew
3465: * WARNING: assumes on TIMECODE == PULSE (timecode after pulse)
3466: */
3467: off = parse->timedata.parse_stime.fp;
3468: L_SUB(&off, &parse->timedata.parse_ptime.fp); /* true offset */
3469: tt = add_var(&out->kv_list, 80, RO);
3470: snprintf(tt, 80, "refclock_ppsskew=%s", lfptoms(&off, 6));
3471: }
3472: }
3473:
3474: if (PARSE_PPS(parse->timedata.parse_state))
3475: {
3476: tt = add_var(&out->kv_list, 80, RO|DEF);
3477: snprintf(tt, 80, "refclock_ppstime=\"%s\"", gmprettydate(&parse->timedata.parse_ptime.fp));
3478: }
3479:
3480: start = tt = add_var(&out->kv_list, 128, RO|DEF);
3481: snprintf(tt, 128, "refclock_time=\"");
3482: tt += strlen(tt);
3483:
3484: if (parse->timedata.parse_time.fp.l_ui == 0)
3485: {
3486: strncpy(tt, "<UNDEFINED>\"", BUFFER_SIZES(start, tt, 128));
3487: }
3488: else
3489: {
3490: snprintf(tt, 128, "%s\"", gmprettydate(&parse->timedata.parse_time.fp));
3491: }
3492:
3493: if (!PARSE_GETTIMECODE(parse, &tmpctl))
3494: {
3495: ERR(ERR_INTERNAL)
3496: msyslog(LOG_ERR, "PARSE receiver #%d: parse_control: parse_timecode() FAILED", unit);
3497: }
3498: else
3499: {
3500: start = tt = add_var(&out->kv_list, 512, RO|DEF);
3501: snprintf(tt, 512, "refclock_status=\"");
3502: tt += strlen(tt);
3503:
3504: /*
3505: * copy PPS flags from last read transaction (informational only)
3506: */
3507: tmpctl.parsegettc.parse_state |= parse->timedata.parse_state &
3508: (PARSEB_PPS|PARSEB_S_PPS);
3509:
3510: (void) parsestate(tmpctl.parsegettc.parse_state, tt, BUFFER_SIZES(start, tt, 512));
3511:
3512: strncat(tt, "\"", BUFFER_SIZES(start, tt, 512));
3513:
3514: if (tmpctl.parsegettc.parse_count)
3515: mkascii(outstatus+strlen(outstatus), (int)(sizeof(outstatus)- strlen(outstatus) - 1),
3516: tmpctl.parsegettc.parse_buffer, (unsigned)(tmpctl.parsegettc.parse_count));
3517:
3518: }
3519:
3520: tmpctl.parseformat.parse_format = tmpctl.parsegettc.parse_format;
3521:
3522: if (!PARSE_GETFMT(parse, &tmpctl))
3523: {
3524: ERR(ERR_INTERNAL)
3525: msyslog(LOG_ERR, "PARSE receiver #%d: parse_control: parse_getfmt() FAILED", unit);
3526: }
3527: else
3528: {
3529: tt = add_var(&out->kv_list, 80, RO|DEF);
3530: snprintf(tt, 80, "refclock_format=\"");
3531:
3532: strncat(tt, tmpctl.parseformat.parse_buffer, tmpctl.parseformat.parse_count);
3533: strncat(tt,"\"", 80);
3534: }
3535:
3536: /*
3537: * gather state statistics
3538: */
3539:
3540: start = tt = add_var(&out->kv_list, LEN_STATES, RO|DEF);
3541: strncpy(tt, "refclock_states=\"", LEN_STATES);
3542: tt += strlen(tt);
3543:
3544: for (i = 0; i <= CEVNT_MAX; i++)
3545: {
3546: u_long s_time;
3547: u_long d = current_time - parse->generic->timestarted;
3548: u_long percent;
3549:
3550: percent = s_time = PARSE_STATETIME(parse, i);
3551:
3552: while (((u_long)(~0) / 10000) < percent)
3553: {
3554: percent /= 10;
3555: d /= 10;
3556: }
3557:
3558: if (d)
3559: percent = (percent * 10000) / d;
3560: else
3561: percent = 10000;
3562:
3563: if (s_time)
3564: {
3565: char item[80];
3566: int count;
3567:
3568: snprintf(item, 80, "%s%s%s: %s (%d.%02d%%)",
3569: sum ? "; " : "",
3570: (parse->generic->currentstatus == i) ? "*" : "",
3571: clockstatus((unsigned int)i),
3572: l_mktime(s_time),
3573: (int)(percent / 100), (int)(percent % 100));
3574: if ((count = strlen(item)) < (LEN_STATES - 40 - (tt - start)))
3575: {
3576: strncpy(tt, item, BUFFER_SIZES(start, tt, LEN_STATES));
3577: tt += count;
3578: }
3579: sum += s_time;
3580: }
3581: }
3582:
3583: snprintf(tt, BUFFER_SIZES(start, tt, LEN_STATES), "; running time: %s\"", l_mktime(sum));
3584:
3585: tt = add_var(&out->kv_list, 32, RO);
3586: snprintf(tt, 32, "refclock_id=\"%s\"", parse->parse_type->cl_id);
3587:
3588: tt = add_var(&out->kv_list, 80, RO);
3589: snprintf(tt, 80, "refclock_iomode=\"%s\"", parse->binding->bd_description);
3590:
3591: tt = add_var(&out->kv_list, 128, RO);
3592: snprintf(tt, 128, "refclock_driver_version=\"%s\"", rcsid);
3593:
3594: {
3595: struct ctl_var *k;
3596:
3597: k = parse->kv;
3598: while (k && !(k->flags & EOV))
3599: {
3600: set_var(&out->kv_list, k->text, strlen(k->text)+1, k->flags);
3601: k++;
3602: }
3603: }
3604:
3605: out->lencode = strlen(outstatus);
3606: out->p_lastcode = outstatus;
3607: }
3608: }
3609:
3610: /**===========================================================================
3611: ** processing routines
3612: **/
3613:
3614: /*--------------------------------------------------
3615: * event handling - note that nominal events will also be posted
3616: * keep track of state dwelling times
3617: */
3618: static void
3619: parse_event(
3620: struct parseunit *parse,
3621: int event
3622: )
3623: {
3624: if (parse->generic->currentstatus != (u_char) event)
3625: {
3626: parse->statetime[parse->generic->currentstatus] += current_time - parse->lastchange;
3627: parse->lastchange = current_time;
3628:
3629: if (parse->parse_type->cl_event)
3630: parse->parse_type->cl_event(parse, event);
3631:
3632: if (event == CEVNT_NOMINAL)
3633: {
3634: NLOG(NLOG_CLOCKSTATUS)
3635: msyslog(LOG_INFO, "PARSE receiver #%d: SYNCHRONIZED",
3636: CLK_UNIT(parse->peer));
3637: }
3638:
3639: refclock_report(parse->peer, event);
3640: }
3641: }
3642:
3643: /*--------------------------------------------------
3644: * process a PARSE time sample
3645: */
3646: static void
3647: parse_process(
3648: struct parseunit *parse,
3649: parsetime_t *parsetime
3650: )
3651: {
3652: l_fp off, rectime, reftime;
3653: double fudge;
3654:
3655: /*
3656: * check for changes in conversion status
3657: * (only one for each new status !)
3658: */
3659: if (((parsetime->parse_status & CVT_MASK) != CVT_OK) &&
3660: ((parsetime->parse_status & CVT_MASK) != CVT_NONE) &&
3661: (parse->timedata.parse_status != parsetime->parse_status))
3662: {
3663: char buffer[400];
3664:
3665: NLOG(NLOG_CLOCKINFO) /* conditional if clause for conditional syslog */
3666: msyslog(LOG_WARNING, "PARSE receiver #%d: conversion status \"%s\"",
3667: CLK_UNIT(parse->peer), parsestatus(parsetime->parse_status, buffer, sizeof(buffer)));
3668:
3669: if ((parsetime->parse_status & CVT_MASK) == CVT_FAIL)
3670: {
3671: /*
3672: * tell more about the story - list time code
3673: * there is a slight change for a race condition and
3674: * the time code might be overwritten by the next packet
3675: */
3676: parsectl_t tmpctl;
3677:
3678: if (!PARSE_GETTIMECODE(parse, &tmpctl))
3679: {
3680: ERR(ERR_INTERNAL)
3681: msyslog(LOG_ERR, "PARSE receiver #%d: parse_process: parse_timecode() FAILED", CLK_UNIT(parse->peer));
3682: }
3683: else
3684: {
3685: ERR(ERR_BADDATA)
3686: msyslog(LOG_WARNING, "PARSE receiver #%d: FAILED TIMECODE: \"%s\" (check receiver configuration / wiring)",
3687: CLK_UNIT(parse->peer), mkascii(buffer, sizeof buffer, tmpctl.parsegettc.parse_buffer, (unsigned)(tmpctl.parsegettc.parse_count - 1)));
3688: }
3689: }
3690: }
3691:
3692: /*
3693: * examine status and post appropriate events
3694: */
3695: if ((parsetime->parse_status & CVT_MASK) != CVT_OK)
3696: {
3697: /*
3698: * got bad data - tell the rest of the system
3699: */
3700: switch (parsetime->parse_status & CVT_MASK)
3701: {
3702: case CVT_NONE:
3703: if ((parsetime->parse_status & CVT_ADDITIONAL) &&
3704: parse->parse_type->cl_message)
3705: parse->parse_type->cl_message(parse, parsetime);
3706: /*
3707: * save PPS information that comes piggyback
3708: */
3709: if (PARSE_PPS(parsetime->parse_state))
3710: {
3711: parse->timedata.parse_state |= PARSEB_PPS|PARSEB_S_PPS;
3712: parse->timedata.parse_ptime = parsetime->parse_ptime;
3713: }
3714: break; /* well, still waiting - timeout is handled at higher levels */
3715:
3716: case CVT_FAIL:
3717: if (parsetime->parse_status & CVT_BADFMT)
3718: {
3719: parse_event(parse, CEVNT_BADREPLY);
3720: }
3721: else
3722: if (parsetime->parse_status & CVT_BADDATE)
3723: {
3724: parse_event(parse, CEVNT_BADDATE);
3725: }
3726: else
3727: if (parsetime->parse_status & CVT_BADTIME)
3728: {
3729: parse_event(parse, CEVNT_BADTIME);
3730: }
3731: else
3732: {
3733: parse_event(parse, CEVNT_BADREPLY); /* for the lack of something better */
3734: }
3735: }
3736: return; /* skip the rest - useless */
3737: }
3738:
3739: /*
3740: * check for format changes
3741: * (in case somebody has swapped clocks 8-)
3742: */
3743: if (parse->lastformat != parsetime->parse_format)
3744: {
3745: parsectl_t tmpctl;
3746:
3747: tmpctl.parseformat.parse_format = parsetime->parse_format;
3748:
3749: if (!PARSE_GETFMT(parse, &tmpctl))
3750: {
3751: ERR(ERR_INTERNAL)
3752: msyslog(LOG_ERR, "PARSE receiver #%d: parse_getfmt() FAILED", CLK_UNIT(parse->peer));
3753: }
3754: else
3755: {
3756: NLOG(NLOG_CLOCKINFO) /* conditional if clause for conditional syslog */
3757: msyslog(LOG_INFO, "PARSE receiver #%d: packet format \"%s\"",
3758: CLK_UNIT(parse->peer), tmpctl.parseformat.parse_buffer);
3759: }
3760: parse->lastformat = parsetime->parse_format;
3761: }
3762:
3763: /*
3764: * now, any changes ?
3765: */
3766: if ((parse->timedata.parse_state ^ parsetime->parse_state) &
3767: ~(unsigned)(PARSEB_PPS|PARSEB_S_PPS))
3768: {
3769: char tmp1[200];
3770: char tmp2[200];
3771: /*
3772: * something happend - except for PPS events
3773: */
3774:
3775: (void) parsestate(parsetime->parse_state, tmp1, sizeof(tmp1));
3776: (void) parsestate(parse->timedata.parse_state, tmp2, sizeof(tmp2));
3777:
3778: NLOG(NLOG_CLOCKINFO) /* conditional if clause for conditional syslog */
3779: msyslog(LOG_INFO,"PARSE receiver #%d: STATE CHANGE: %s -> %s",
3780: CLK_UNIT(parse->peer), tmp2, tmp1);
3781: }
3782:
3783: /*
3784: * carry on PPS information if still usable
3785: */
3786: if (PARSE_PPS(parse->timedata.parse_state) && !PARSE_PPS(parsetime->parse_state))
3787: {
3788: parsetime->parse_state |= PARSEB_PPS|PARSEB_S_PPS;
3789: parsetime->parse_ptime = parse->timedata.parse_ptime;
3790: }
3791:
3792: /*
3793: * remember for future
3794: */
3795: parse->timedata = *parsetime;
3796:
3797: /*
3798: * check to see, whether the clock did a complete powerup or lost PZF signal
3799: * and post correct events for current condition
3800: */
3801: if (PARSE_POWERUP(parsetime->parse_state))
3802: {
3803: /*
3804: * this is bad, as we have completely lost synchronisation
3805: * well this is a problem with the receiver here
3806: * for PARSE Meinberg DCF77 receivers the lost synchronisation
3807: * is true as it is the powerup state and the time is taken
3808: * from a crude real time clock chip
3809: * for the PZF/GPS series this is only partly true, as
3810: * PARSE_POWERUP only means that the pseudo random
3811: * phase shift sequence cannot be found. this is only
3812: * bad, if we have never seen the clock in the SYNC
3813: * state, where the PHASE and EPOCH are correct.
3814: * for reporting events the above business does not
3815: * really matter, but we can use the time code
3816: * even in the POWERUP state after having seen
3817: * the clock in the synchronized state (PZF class
3818: * receivers) unless we have had a telegram disruption
3819: * after having seen the clock in the SYNC state. we
3820: * thus require having seen the clock in SYNC state
3821: * *after* having missed telegrams (noresponse) from
3822: * the clock. one problem remains: we might use erroneously
3823: * POWERUP data if the disruption is shorter than 1 polling
3824: * interval. fortunately powerdowns last usually longer than 64
3825: * seconds and the receiver is at least 2 minutes in the
3826: * POWERUP or NOSYNC state before switching to SYNC
3827: * for GPS receivers this can mean antenna problems and other causes.
3828: * the additional grace period can be enables by a clock
3829: * mode having the PARSE_F_POWERUPTRUST flag in cl_flag set.
3830: */
3831: parse_event(parse, CEVNT_FAULT);
3832: NLOG(NLOG_CLOCKSTATUS)
3833: ERR(ERR_BADSTATUS)
3834: msyslog(LOG_ERR,"PARSE receiver #%d: NOT SYNCHRONIZED/RECEIVER PROBLEMS",
3835: CLK_UNIT(parse->peer));
3836: }
3837: else
3838: {
3839: /*
3840: * we have two states left
3841: *
3842: * SYNC:
3843: * this state means that the EPOCH (timecode) and PHASE
3844: * information has be read correctly (at least two
3845: * successive PARSE timecodes were received correctly)
3846: * this is the best possible state - full trust
3847: *
3848: * NOSYNC:
3849: * The clock should be on phase with respect to the second
3850: * signal, but the timecode has not been received correctly within
3851: * at least the last two minutes. this is a sort of half baked state
3852: * for PARSE Meinberg DCF77 clocks this is bad news (clock running
3853: * without timecode confirmation)
3854: * PZF 535 has also no time confirmation, but the phase should be
3855: * very precise as the PZF signal can be decoded
3856: */
3857:
3858: if (PARSE_SYNC(parsetime->parse_state))
3859: {
3860: /*
3861: * currently completely synchronized - best possible state
3862: */
3863: parse->lastsync = current_time;
3864: clear_err(parse, ERR_BADSTATUS);
3865: }
3866: else
3867: {
3868: /*
3869: * we have had some problems receiving the time code
3870: */
3871: parse_event(parse, CEVNT_PROP);
3872: NLOG(NLOG_CLOCKSTATUS)
3873: ERR(ERR_BADSTATUS)
3874: msyslog(LOG_ERR,"PARSE receiver #%d: TIMECODE NOT CONFIRMED",
3875: CLK_UNIT(parse->peer));
3876: }
3877: }
3878:
3879: fudge = parse->generic->fudgetime1; /* standard RS232 Fudgefactor */
3880:
3881: if (PARSE_TIMECODE(parsetime->parse_state))
3882: {
3883: rectime = parsetime->parse_stime.fp;
3884: off = reftime = parsetime->parse_time.fp;
3885:
3886: L_SUB(&off, &rectime); /* prepare for PPS adjustments logic */
3887:
3888: #ifdef DEBUG
3889: if (debug > 3)
3890: printf("PARSE receiver #%d: Reftime %s, Recvtime %s - initial offset %s\n",
3891: CLK_UNIT(parse->peer),
3892: prettydate(&reftime),
3893: prettydate(&rectime),
3894: lfptoa(&off,6));
3895: #endif
3896: }
3897:
3898: if (PARSE_PPS(parsetime->parse_state) && CLK_PPS(parse->peer))
3899: {
3900: l_fp offset;
3901: double ppsphaseadjust = parse->ppsphaseadjust;
3902:
3903: #ifdef HAVE_PPSAPI
3904: /*
3905: * set fudge = 0.0 if already included in PPS time stamps
3906: */
3907: if (parse->atom.pps_params.mode & (PPS_OFFSETCLEAR|PPS_OFFSETASSERT))
3908: {
3909: ppsphaseadjust = 0.0;
3910: }
3911: #endif
3912:
3913: /*
3914: * we have a PPS signal - much better than the RS232 stuff (we hope)
3915: */
3916: offset = parsetime->parse_ptime.fp;
3917:
3918: #ifdef DEBUG
3919: if (debug > 3)
3920: printf("PARSE receiver #%d: PPStime %s\n",
3921: CLK_UNIT(parse->peer),
3922: prettydate(&offset));
3923: #endif
3924: if (PARSE_TIMECODE(parsetime->parse_state))
3925: {
3926: if (M_ISGEQ(off.l_i, off.l_f, -1, 0x80000000) &&
3927: M_ISGEQ(0, 0x7fffffff, off.l_i, off.l_f))
3928: {
3929: fudge = ppsphaseadjust; /* pick PPS fudge factor */
3930:
3931: /*
3932: * RS232 offsets within [-0.5..0.5[ - take PPS offsets
3933: */
3934:
3935: if (parse->parse_type->cl_flags & PARSE_F_PPSONSECOND)
3936: {
3937: reftime = off = offset;
3938: if (reftime.l_uf & (unsigned)0x80000000)
3939: reftime.l_ui++;
3940: reftime.l_uf = 0;
3941:
3942:
3943: /*
3944: * implied on second offset
3945: */
3946: off.l_uf = ~off.l_uf; /* map [0.5..1[ -> [-0.5..0[ */
3947: off.l_ui = (off.l_f < 0) ? ~0 : 0; /* sign extend */
3948: }
3949: else
3950: {
3951: /*
3952: * time code describes pulse
3953: */
3954: reftime = off = parsetime->parse_time.fp;
3955:
3956: L_SUB(&off, &offset); /* true offset */
3957: }
3958: }
3959: /*
3960: * take RS232 offset when PPS when out of bounds
3961: */
3962: }
3963: else
3964: {
3965: fudge = ppsphaseadjust; /* pick PPS fudge factor */
3966: /*
3967: * Well, no time code to guide us - assume on second pulse
3968: * and pray, that we are within [-0.5..0.5[
3969: */
3970: off = offset;
3971: reftime = offset;
3972: if (reftime.l_uf & (unsigned)0x80000000)
3973: reftime.l_ui++;
3974: reftime.l_uf = 0;
3975: /*
3976: * implied on second offset
3977: */
3978: off.l_uf = ~off.l_uf; /* map [0.5..1[ -> [-0.5..0[ */
3979: off.l_ui = (off.l_f < 0) ? ~0 : 0; /* sign extend */
3980: }
3981: }
3982: else
3983: {
3984: if (!PARSE_TIMECODE(parsetime->parse_state))
3985: {
3986: /*
3987: * Well, no PPS, no TIMECODE, no more work ...
3988: */
3989: if ((parsetime->parse_status & CVT_ADDITIONAL) &&
3990: parse->parse_type->cl_message)
3991: parse->parse_type->cl_message(parse, parsetime);
3992: return;
3993: }
3994: }
3995:
3996: #ifdef DEBUG
3997: if (debug > 3)
3998: printf("PARSE receiver #%d: Reftime %s, Recvtime %s - final offset %s\n",
3999: CLK_UNIT(parse->peer),
4000: prettydate(&reftime),
4001: prettydate(&rectime),
4002: lfptoa(&off,6));
4003: #endif
4004:
4005:
4006: rectime = reftime;
4007: L_SUB(&rectime, &off); /* just to keep the ntp interface happy */
4008:
4009: #ifdef DEBUG
4010: if (debug > 3)
4011: printf("PARSE receiver #%d: calculated Reftime %s, Recvtime %s\n",
4012: CLK_UNIT(parse->peer),
4013: prettydate(&reftime),
4014: prettydate(&rectime));
4015: #endif
4016:
4017: if ((parsetime->parse_status & CVT_ADDITIONAL) &&
4018: parse->parse_type->cl_message)
4019: parse->parse_type->cl_message(parse, parsetime);
4020:
4021: if (PARSE_SYNC(parsetime->parse_state))
4022: {
4023: /*
4024: * log OK status
4025: */
4026: parse_event(parse, CEVNT_NOMINAL);
4027: }
4028:
4029: clear_err(parse, ERR_BADIO);
4030: clear_err(parse, ERR_BADDATA);
4031: clear_err(parse, ERR_NODATA);
4032: clear_err(parse, ERR_INTERNAL);
4033:
4034: /*
4035: * and now stick it into the clock machine
4036: * samples are only valid iff lastsync is not too old and
4037: * we have seen the clock in sync at least once
4038: * after the last time we didn't see an expected data telegram
4039: * at startup being not in sync is also bad just like
4040: * POWERUP state unless PARSE_F_POWERUPTRUST is set
4041: * see the clock states section above for more reasoning
4042: */
4043: if (((current_time - parse->lastsync) > parse->maxunsync) ||
4044: (parse->lastsync < parse->lastmissed) ||
4045: ((parse->lastsync == 0) && !PARSE_SYNC(parsetime->parse_state)) ||
4046: (((parse->parse_type->cl_flags & PARSE_F_POWERUPTRUST) == 0) &&
4047: PARSE_POWERUP(parsetime->parse_state)))
4048: {
4049: parse->generic->leap = LEAP_NOTINSYNC;
4050: parse->lastsync = 0; /* wait for full sync again */
4051: }
4052: else
4053: {
4054: if (PARSE_LEAPADD(parsetime->parse_state))
4055: {
4056: /*
4057: * we pick this state also for time code that pass leap warnings
4058: * without direction information (as earth is currently slowing
4059: * down).
4060: */
4061: parse->generic->leap = (parse->flags & PARSE_LEAP_DELETE) ? LEAP_DELSECOND : LEAP_ADDSECOND;
4062: }
4063: else
4064: if (PARSE_LEAPDEL(parsetime->parse_state))
4065: {
4066: parse->generic->leap = LEAP_DELSECOND;
4067: }
4068: else
4069: {
4070: parse->generic->leap = LEAP_NOWARNING;
4071: }
4072: }
4073:
4074: if (parse->generic->leap != LEAP_NOTINSYNC)
4075: {
4076: /*
4077: * only good/trusted samples are interesting
4078: */
4079: #ifdef DEBUG
4080: if (debug > 2)
4081: {
4082: printf("PARSE receiver #%d: refclock_process_offset(reftime=%s, rectime=%s, Fudge=%f)\n",
4083: CLK_UNIT(parse->peer),
4084: prettydate(&reftime),
4085: prettydate(&rectime),
4086: fudge);
4087: }
4088: #endif
4089: parse->generic->lastref = reftime;
4090:
4091: refclock_process_offset(parse->generic, reftime, rectime, fudge);
4092:
4093: #ifdef HAVE_PPSAPI
4094: /*
4095: * pass PPS information on to PPS clock
4096: */
4097: if (PARSE_PPS(parsetime->parse_state) && CLK_PPS(parse->peer))
4098: {
4099: /* refclock_pps includes fudgetime1 - we keep the RS232 offset in there :-( */
4100: double savedtime1 = parse->generic->fudgetime1;
4101:
4102: parse->generic->fudgetime1 = fudge;
4103:
4104: if (refclock_pps(parse->peer, &parse->atom,
4105: parse->flags & (CLK_FLAG1|CLK_FLAG2|CLK_FLAG3|CLK_FLAG4))) {
4106: parse->peer->flags |= FLAG_PPS;
4107: } else {
4108: parse->peer->flags &= ~FLAG_PPS;
4109: }
4110:
4111: parse->generic->fudgetime1 = savedtime1;
4112:
4113: parse_hardpps(parse, PARSE_HARDPPS_ENABLE);
4114: }
4115: #endif
4116: } else {
4117: parse_hardpps(parse, PARSE_HARDPPS_DISABLE);
4118: parse->peer->flags &= ~FLAG_PPS;
4119: }
4120:
4121: /*
4122: * ready, unless the machine wants a sample or
4123: * we are in fast startup mode (peer->dist > MAXDISTANCE)
4124: */
4125: if (!parse->pollneeddata && parse->peer->disp <= MAXDISTANCE)
4126: return;
4127:
4128: parse->pollneeddata = 0;
4129:
4130: parse->timedata.parse_state &= ~(unsigned)(PARSEB_PPS|PARSEB_S_PPS);
4131:
4132: refclock_receive(parse->peer);
4133: }
4134:
4135: /**===========================================================================
4136: ** special code for special clocks
4137: **/
4138:
4139: static void
4140: mk_utcinfo(
4141: char *t,
4142: int wnt,
4143: int wnlsf,
4144: int dn,
4145: int dtls,
4146: int dtlsf,
4147: int size
4148: )
4149: {
4150: l_fp leapdate;
4151: char *start = t;
4152:
4153: snprintf(t, size, "current correction %d sec", dtls);
4154: t += strlen(t);
4155:
4156: if (wnlsf < 990)
4157: wnlsf += 1024;
4158:
4159: if (wnt < 990)
4160: wnt += 1024;
4161:
4162: gpstolfp((unsigned short)wnlsf, (unsigned short)dn, 0, &leapdate);
4163:
4164: if ((dtlsf != dtls) &&
4165: ((wnlsf - wnt) < 52))
4166: {
4167: snprintf(t, BUFFER_SIZES(start, t, size), ", next correction %d sec on %s, new GPS-UTC offset %d",
4168: dtlsf - dtls, gmprettydate(&leapdate), dtlsf);
4169: }
4170: else
4171: {
4172: snprintf(t, BUFFER_SIZES(start, t, size), ", last correction on %s",
4173: gmprettydate(&leapdate));
4174: }
4175: }
4176:
4177: #ifdef CLOCK_MEINBERG
4178: /**===========================================================================
4179: ** Meinberg GPS166/GPS167 support
4180: **/
4181:
4182: /*------------------------------------------------------------
4183: * gps16x_message - process GPS16x messages
4184: */
4185: static void
4186: gps16x_message(
4187: struct parseunit *parse,
4188: parsetime_t *parsetime
4189: )
4190: {
4191: if (parse->timedata.parse_msglen && parsetime->parse_msg[0] == SOH)
4192: {
4193: GPS_MSG_HDR header;
4194: unsigned char *bufp = (unsigned char *)parsetime->parse_msg + 1;
4195:
4196: #ifdef DEBUG
4197: if (debug > 2)
4198: {
4199: char msgbuffer[600];
4200:
4201: mkreadable(msgbuffer, sizeof(msgbuffer), (char *)parsetime->parse_msg, parsetime->parse_msglen, 1);
4202: printf("PARSE receiver #%d: received message (%d bytes) >%s<\n",
4203: CLK_UNIT(parse->peer),
4204: parsetime->parse_msglen,
4205: msgbuffer);
4206: }
4207: #endif
4208: get_mbg_header(&bufp, &header);
4209: if (header.gps_hdr_csum == mbg_csum(parsetime->parse_msg + 1, 6) &&
4210: (header.gps_len == 0 ||
4211: (header.gps_len < sizeof(parsetime->parse_msg) &&
4212: header.gps_data_csum == mbg_csum(bufp, header.gps_len))))
4213: {
4214: /*
4215: * clean message
4216: */
4217: switch (header.gps_cmd)
4218: {
4219: case GPS_SW_REV:
4220: {
4221: char buffer[64];
4222: SW_REV gps_sw_rev;
4223:
4224: get_mbg_sw_rev(&bufp, &gps_sw_rev);
4225: snprintf(buffer, sizeof(buffer), "meinberg_gps_version=\"%x.%02x%s%s\"",
4226: (gps_sw_rev.code >> 8) & 0xFF,
4227: gps_sw_rev.code & 0xFF,
4228: gps_sw_rev.name[0] ? " " : "",
4229: gps_sw_rev.name);
4230: set_var(&parse->kv, buffer, strlen(buffer)+1, RO|DEF);
4231: }
4232: break;
4233:
4234: case GPS_STAT:
4235: {
4236: static struct state
4237: {
4238: unsigned short flag; /* status flag */
4239: unsigned const char *string; /* bit name */
4240: } states[] =
4241: {
4242: { TM_ANT_DISCONN, (const unsigned char *)"ANTENNA FAULTY" },
4243: { TM_SYN_FLAG, (const unsigned char *)"NO SYNC SIGNAL" },
4244: { TM_NO_SYNC, (const unsigned char *)"NO SYNC POWERUP" },
4245: { TM_NO_POS, (const unsigned char *)"NO POSITION" },
4246: { 0, (const unsigned char *)"" }
4247: };
4248: unsigned short status;
4249: struct state *s = states;
4250: char buffer[512];
4251: char *p, *b;
4252:
4253: status = get_lsb_short(&bufp);
4254: snprintf(buffer, sizeof(buffer), "meinberg_gps_status=\"[0x%04x] ", status);
4255:
4256: if (status)
4257: {
4258: p = b = buffer + strlen(buffer);
4259: while (s->flag)
4260: {
4261: if (status & s->flag)
4262: {
4263: if (p != b)
4264: {
4265: *p++ = ',';
4266: *p++ = ' ';
4267: }
4268:
4269: strncat(p, (const char *)s->string, sizeof(buffer));
4270: }
4271: s++;
4272: }
4273:
4274: *p++ = '"';
4275: *p = '\0';
4276: }
4277: else
4278: {
4279: strncat(buffer, "<OK>\"", sizeof(buffer));
4280: }
4281:
4282: set_var(&parse->kv, buffer, strlen(buffer)+1, RO|DEF);
4283: }
4284: break;
4285:
4286: case GPS_POS_XYZ:
4287: {
4288: XYZ xyz;
4289: char buffer[256];
4290:
4291: get_mbg_xyz(&bufp, xyz);
4292: snprintf(buffer, sizeof(buffer), "gps_position(XYZ)=\"%s m, %s m, %s m\"",
4293: mfptoa(xyz[XP].l_ui, xyz[XP].l_uf, 1),
4294: mfptoa(xyz[YP].l_ui, xyz[YP].l_uf, 1),
4295: mfptoa(xyz[ZP].l_ui, xyz[ZP].l_uf, 1));
4296:
4297: set_var(&parse->kv, buffer, sizeof(buffer), RO|DEF);
4298: }
4299: break;
4300:
4301: case GPS_POS_LLA:
4302: {
4303: LLA lla;
4304: char buffer[256];
4305:
4306: get_mbg_lla(&bufp, lla);
4307:
4308: snprintf(buffer, sizeof(buffer), "gps_position(LLA)=\"%s deg, %s deg, %s m\"",
4309: mfptoa(lla[LAT].l_ui, lla[LAT].l_uf, 4),
4310: mfptoa(lla[LON].l_ui, lla[LON].l_uf, 4),
4311: mfptoa(lla[ALT].l_ui, lla[ALT].l_uf, 1));
4312:
4313: set_var(&parse->kv, buffer, sizeof(buffer), RO|DEF);
4314: }
4315: break;
4316:
4317: case GPS_TZDL:
4318: break;
4319:
4320: case GPS_PORT_PARM:
4321: break;
4322:
4323: case GPS_SYNTH:
4324: break;
4325:
4326: case GPS_ANT_INFO:
4327: {
4328: ANT_INFO antinfo;
4329: char buffer[512];
4330: char *p;
4331:
4332: get_mbg_antinfo(&bufp, &antinfo);
4333: snprintf(buffer, sizeof(buffer), "meinberg_antenna_status=\"");
4334: p = buffer + strlen(buffer);
4335:
4336: switch (antinfo.status)
4337: {
4338: case ANT_INVALID:
4339: strncat(p, "<OK>", BUFFER_SIZE(buffer, p));
4340: p += strlen(p);
4341: break;
4342:
4343: case ANT_DISCONN:
4344: strncat(p, "DISCONNECTED since ", BUFFER_SIZE(buffer, p));
4345: NLOG(NLOG_CLOCKSTATUS)
4346: ERR(ERR_BADSTATUS)
4347: msyslog(LOG_ERR,"PARSE receiver #%d: ANTENNA FAILURE: %s",
4348: CLK_UNIT(parse->peer), p);
4349:
4350: p += strlen(p);
4351: mbg_tm_str(&p, &antinfo.tm_disconn, BUFFER_SIZE(buffer, p));
4352: *p = '\0';
4353: break;
4354:
4355: case ANT_RECONN:
4356: strncat(p, "RECONNECTED on ", BUFFER_SIZE(buffer, p));
4357: p += strlen(p);
4358: mbg_tm_str(&p, &antinfo.tm_reconn, BUFFER_SIZE(buffer, p));
4359: snprintf(p, BUFFER_SIZE(buffer, p), ", reconnect clockoffset %c%ld.%07ld s, disconnect time ",
4360: (antinfo.delta_t < 0) ? '-' : '+',
4361: ABS(antinfo.delta_t) / 10000,
4362: ABS(antinfo.delta_t) % 10000);
4363: p += strlen(p);
4364: mbg_tm_str(&p, &antinfo.tm_disconn, BUFFER_SIZE(buffer, p));
4365: *p = '\0';
4366: break;
4367:
4368: default:
4369: snprintf(p, BUFFER_SIZE(buffer, p), "bad status 0x%04x", antinfo.status);
4370: p += strlen(p);
4371: break;
4372: }
4373:
4374: strncat(p, "\"", BUFFER_SIZE(buffer, p));
4375:
4376: set_var(&parse->kv, buffer, strlen(buffer)+1, RO|DEF);
4377: }
4378: break;
4379:
4380: case GPS_UCAP:
4381: break;
4382:
4383: case GPS_CFGH:
4384: {
4385: CFGH cfgh;
4386: char buffer[512];
4387: char *p;
4388:
4389: get_mbg_cfgh(&bufp, &cfgh);
4390: if (cfgh.valid)
4391: {
4392: int i;
4393:
4394: p = buffer;
4395: strncpy(buffer, "gps_tot_51=\"", BUFFER_SIZE(buffer, p));
4396: p += strlen(p);
4397: mbg_tgps_str(&p, &cfgh.tot_51, BUFFER_SIZE(buffer, p));
4398: strncpy(p, "\"", BUFFER_SIZE(buffer, p));
4399: set_var(&parse->kv, buffer, strlen(buffer)+1, RO);
4400:
4401: p = buffer;
4402: strncpy(buffer, "gps_tot_63=\"", BUFFER_SIZE(buffer, p));
4403: p += strlen(p);
4404: mbg_tgps_str(&p, &cfgh.tot_63, BUFFER_SIZE(buffer, p));
4405: strncpy(p, "\"", BUFFER_SIZE(buffer, p));
4406: set_var(&parse->kv, buffer, strlen(buffer)+1, RO);
4407:
4408: p = buffer;
4409: strncpy(buffer, "gps_t0a=\"", BUFFER_SIZE(buffer, p));
4410: p += strlen(p);
4411: mbg_tgps_str(&p, &cfgh.t0a, BUFFER_SIZE(buffer, p));
4412: strncpy(p, "\"", BUFFER_SIZE(buffer, p));
4413: set_var(&parse->kv, buffer, strlen(buffer)+1, RO);
4414:
4415: for (i = MIN_SVNO; i < MAX_SVNO; i++)
4416: {
4417: p = buffer;
4418: snprintf(p, BUFFER_SIZE(buffer, p), "gps_cfg[%d]=\"[0x%x] ", i, cfgh.cfg[i]);
4419: p += strlen(p);
4420: switch (cfgh.cfg[i] & 0x7)
4421: {
4422: case 0:
4423: strncpy(p, "BLOCK I", BUFFER_SIZE(buffer, p));
4424: break;
4425: case 1:
4426: strncpy(p, "BLOCK II", BUFFER_SIZE(buffer, p));
4427: break;
4428: default:
4429: strncpy(p, "bad CFG", BUFFER_SIZE(buffer, p));
4430: break;
4431: }
4432: strncat(p, "\"", BUFFER_SIZE(buffer, p));
4433: set_var(&parse->kv, buffer, strlen(buffer)+1, RO);
4434:
4435: p = buffer;
4436: snprintf(p, BUFFER_SIZE(buffer, p), "gps_health[%d]=\"[0x%x] ", i, cfgh.health[i]);
4437: p += strlen(p);
4438: switch ((cfgh.health[i] >> 5) & 0x7 )
4439: {
4440: case 0:
4441: strncpy(p, "OK;", BUFFER_SIZE(buffer, p));
4442: break;
4443: case 1:
4444: strncpy(p, "PARITY;", BUFFER_SIZE(buffer, p));
4445: break;
4446: case 2:
4447: strncpy(p, "TLM/HOW;", BUFFER_SIZE(buffer, p));
4448: break;
4449: case 3:
4450: strncpy(p, "Z-COUNT;", BUFFER_SIZE(buffer, p));
4451: break;
4452: case 4:
4453: strncpy(p, "SUBFRAME 1,2,3;", BUFFER_SIZE(buffer, p));
4454: break;
4455: case 5:
4456: strncpy(p, "SUBFRAME 4,5;", BUFFER_SIZE(buffer, p));
4457: break;
4458: case 6:
4459: strncpy(p, "UPLOAD BAD;", BUFFER_SIZE(buffer, p));
4460: break;
4461: case 7:
4462: strncpy(p, "DATA BAD;", BUFFER_SIZE(buffer, p));
4463: break;
4464: }
4465:
4466: p += strlen(p);
4467:
4468: switch (cfgh.health[i] & 0x1F)
4469: {
4470: case 0:
4471: strncpy(p, "SIGNAL OK", BUFFER_SIZE(buffer, p));
4472: break;
4473: case 0x1C:
4474: strncpy(p, "SV TEMP OUT", BUFFER_SIZE(buffer, p));
4475: break;
4476: case 0x1D:
4477: strncpy(p, "SV WILL BE TEMP OUT", BUFFER_SIZE(buffer, p));
4478: break;
4479: case 0x1E:
4480: break;
4481: case 0x1F:
4482: strncpy(p, "MULTIPLE ERRS", BUFFER_SIZE(buffer, p));
4483: break;
4484: default:
4485: strncpy(p, "TRANSMISSION PROBLEMS", BUFFER_SIZE(buffer, p));
4486: break;
4487: }
4488:
4489: strncat(p, "\"", sizeof(buffer));
4490: set_var(&parse->kv, buffer, strlen(buffer)+1, RO);
4491: }
4492: }
4493: }
4494: break;
4495:
4496: case GPS_ALM:
4497: break;
4498:
4499: case GPS_EPH:
4500: break;
4501:
4502: case GPS_UTC:
4503: {
4504: UTC utc;
4505: char buffer[512];
4506: char *p;
4507:
4508: p = buffer;
4509:
4510: get_mbg_utc(&bufp, &utc);
4511:
4512: if (utc.valid)
4513: {
4514: strncpy(p, "gps_utc_correction=\"", sizeof(buffer));
4515: p += strlen(p);
4516: mk_utcinfo(p, utc.t0t.wn, utc.WNlsf, utc.DNt, utc.delta_tls, utc.delta_tlsf, BUFFER_SIZE(buffer, p));
4517: strncat(p, "\"", BUFFER_SIZE(buffer, p));
4518: }
4519: else
4520: {
4521: strncpy(p, "gps_utc_correction=\"<NO UTC DATA>\"", BUFFER_SIZE(buffer, p));
4522: }
4523: set_var(&parse->kv, buffer, strlen(buffer)+1, RO|DEF);
4524: }
4525: break;
4526:
4527: case GPS_IONO:
4528: break;
4529:
4530: case GPS_ASCII_MSG:
4531: {
4532: ASCII_MSG gps_ascii_msg;
4533: char buffer[128];
4534:
4535: get_mbg_ascii_msg(&bufp, &gps_ascii_msg);
4536:
4537: if (gps_ascii_msg.valid)
4538: {
4539: char buffer1[128];
4540: mkreadable(buffer1, sizeof(buffer1), gps_ascii_msg.s, strlen(gps_ascii_msg.s), (int)0);
4541:
4542: snprintf(buffer, sizeof(buffer), "gps_message=\"%s\"", buffer1);
4543: }
4544: else
4545: strncpy(buffer, "gps_message=<NONE>", sizeof(buffer));
4546:
4547: set_var(&parse->kv, buffer, strlen(buffer)+1, RO|DEF);
4548: }
4549:
4550: break;
4551:
4552: default:
4553: break;
4554: }
4555: }
4556: else
4557: {
4558: msyslog(LOG_DEBUG, "PARSE receiver #%d: gps16x_message: message checksum error: hdr_csum = 0x%x (expected 0x%lx), data_len = %d, data_csum = 0x%x (expected 0x%lx)",
4559: CLK_UNIT(parse->peer),
4560: header.gps_hdr_csum, mbg_csum(parsetime->parse_msg + 1, 6),
4561: header.gps_len,
4562: header.gps_data_csum, mbg_csum(bufp, (unsigned)((header.gps_len < sizeof(parsetime->parse_msg)) ? header.gps_len : 0)));
4563: }
4564: }
4565:
4566: return;
4567: }
4568:
4569: /*------------------------------------------------------------
4570: * gps16x_poll - query the reciver peridically
4571: */
4572: static void
4573: gps16x_poll(
4574: struct peer *peer
4575: )
4576: {
4577: struct parseunit *parse = (struct parseunit *)peer->procptr->unitptr;
4578:
4579: static GPS_MSG_HDR sequence[] =
4580: {
4581: { GPS_SW_REV, 0, 0, 0 },
4582: { GPS_STAT, 0, 0, 0 },
4583: { GPS_UTC, 0, 0, 0 },
4584: { GPS_ASCII_MSG, 0, 0, 0 },
4585: { GPS_ANT_INFO, 0, 0, 0 },
4586: { GPS_CFGH, 0, 0, 0 },
4587: { GPS_POS_XYZ, 0, 0, 0 },
4588: { GPS_POS_LLA, 0, 0, 0 },
4589: { (unsigned short)~0, 0, 0, 0 }
4590: };
4591:
4592: int rtc;
4593: unsigned char cmd_buffer[64];
4594: unsigned char *outp = cmd_buffer;
4595: GPS_MSG_HDR *header;
4596:
4597: if (((poll_info_t *)parse->parse_type->cl_data)->rate)
4598: {
4599: parse->peer->nextaction = current_time + ((poll_info_t *)parse->parse_type->cl_data)->rate;
4600: }
4601:
4602: if (sequence[parse->localstate].gps_cmd == (unsigned short)~0)
4603: parse->localstate = 0;
4604:
4605: header = sequence + parse->localstate++;
4606:
4607: *outp++ = SOH; /* start command */
4608:
4609: put_mbg_header(&outp, header);
4610: outp = cmd_buffer + 1;
4611:
4612: header->gps_hdr_csum = (short)mbg_csum(outp, 6);
4613: put_mbg_header(&outp, header);
4614:
4615: #ifdef DEBUG
4616: if (debug > 2)
4617: {
4618: char buffer[128];
4619:
4620: mkreadable(buffer, sizeof(buffer), (char *)cmd_buffer, (unsigned)(outp - cmd_buffer), 1);
4621: printf("PARSE receiver #%d: transmitted message #%ld (%d bytes) >%s<\n",
4622: CLK_UNIT(parse->peer),
4623: parse->localstate - 1,
4624: (int)(outp - cmd_buffer),
4625: buffer);
4626: }
4627: #endif
4628:
4629: rtc = write(parse->generic->io.fd, cmd_buffer, (unsigned long)(outp - cmd_buffer));
4630:
4631: if (rtc < 0)
4632: {
4633: ERR(ERR_BADIO)
4634: msyslog(LOG_ERR, "PARSE receiver #%d: gps16x_poll: failed to send cmd to clock: %m", CLK_UNIT(parse->peer));
4635: }
4636: else
4637: if (rtc != outp - cmd_buffer)
4638: {
4639: ERR(ERR_BADIO)
4640: msyslog(LOG_ERR, "PARSE receiver #%d: gps16x_poll: failed to send cmd incomplete (%d of %d bytes sent)", CLK_UNIT(parse->peer), rtc, (int)(outp - cmd_buffer));
4641: }
4642:
4643: clear_err(parse, ERR_BADIO);
4644: return;
4645: }
4646:
4647: /*--------------------------------------------------
4648: * init routine - setup timer
4649: */
4650: static int
4651: gps16x_poll_init(
4652: struct parseunit *parse
4653: )
4654: {
4655: if (((poll_info_t *)parse->parse_type->cl_data)->rate)
4656: {
4657: parse->peer->action = gps16x_poll;
4658: gps16x_poll(parse->peer);
4659: }
4660:
4661: return 0;
4662: }
4663:
4664: #else
4665: static void
4666: gps16x_message(
4667: struct parseunit *parse,
4668: parsetime_t *parsetime
4669: )
4670: {}
4671: static int
4672: gps16x_poll_init(
4673: struct parseunit *parse
4674: )
4675: {
4676: return 1;
4677: }
4678: #endif /* CLOCK_MEINBERG */
4679:
4680: /**===========================================================================
4681: ** clock polling support
4682: **/
4683:
4684: /*--------------------------------------------------
4685: * direct poll routine
4686: */
4687: static void
4688: poll_dpoll(
4689: struct parseunit *parse
4690: )
4691: {
4692: int rtc;
4693: const char *ps = ((poll_info_t *)parse->parse_type->cl_data)->string;
4694: int ct = ((poll_info_t *)parse->parse_type->cl_data)->count;
4695:
4696: rtc = write(parse->generic->io.fd, ps, (unsigned long)ct);
4697: if (rtc < 0)
4698: {
4699: ERR(ERR_BADIO)
4700: msyslog(LOG_ERR, "PARSE receiver #%d: poll_dpoll: failed to send cmd to clock: %m", CLK_UNIT(parse->peer));
4701: }
4702: else
4703: if (rtc != ct)
4704: {
4705: ERR(ERR_BADIO)
4706: msyslog(LOG_ERR, "PARSE receiver #%d: poll_dpoll: failed to send cmd incomplete (%d of %d bytes sent)", CLK_UNIT(parse->peer), rtc, ct);
4707: }
4708: clear_err(parse, ERR_BADIO);
4709: }
4710:
4711: /*--------------------------------------------------
4712: * periodic poll routine
4713: */
4714: static void
4715: poll_poll(
4716: struct peer *peer
4717: )
4718: {
4719: struct parseunit *parse = (struct parseunit *)peer->procptr->unitptr;
4720:
4721: if (parse->parse_type->cl_poll)
4722: parse->parse_type->cl_poll(parse);
4723:
4724: if (((poll_info_t *)parse->parse_type->cl_data)->rate)
4725: {
4726: parse->peer->nextaction = current_time + ((poll_info_t *)parse->parse_type->cl_data)->rate;
4727: }
4728: }
4729:
4730: /*--------------------------------------------------
4731: * init routine - setup timer
4732: */
4733: static int
4734: poll_init(
4735: struct parseunit *parse
4736: )
4737: {
4738: if (((poll_info_t *)parse->parse_type->cl_data)->rate)
4739: {
4740: parse->peer->action = poll_poll;
4741: poll_poll(parse->peer);
4742: }
4743:
4744: return 0;
4745: }
4746:
4747: /**===========================================================================
4748: ** Trimble support
4749: **/
4750:
4751: /*-------------------------------------------------------------
4752: * trimble TAIP init routine - setup EOL and then do poll_init.
4753: */
4754: static int
4755: trimbletaip_init(
4756: struct parseunit *parse
4757: )
4758: {
4759: #ifdef HAVE_TERMIOS
4760: struct termios tio;
4761: #endif
4762: #ifdef HAVE_SYSV_TTYS
4763: struct termio tio;
4764: #endif
4765: /*
4766: * configure terminal line for trimble receiver
4767: */
4768: if (TTY_GETATTR(parse->generic->io.fd, &tio) == -1)
4769: {
4770: msyslog(LOG_ERR, "PARSE receiver #%d: trimbletaip_init: tcgetattr(fd, &tio): %m", CLK_UNIT(parse->peer));
4771: return 0;
4772: }
4773: else
4774: {
4775: tio.c_cc[VEOL] = TRIMBLETAIP_EOL;
4776:
4777: if (TTY_SETATTR(parse->generic->io.fd, &tio) == -1)
4778: {
4779: msyslog(LOG_ERR, "PARSE receiver #%d: trimbletaip_init: tcsetattr(fd, &tio): %m", CLK_UNIT(parse->peer));
4780: return 0;
4781: }
4782: }
4783: return poll_init(parse);
4784: }
4785:
4786: /*--------------------------------------------------
4787: * trimble TAIP event routine - reset receiver upon data format trouble
4788: */
4789: static const char *taipinit[] = {
4790: ">FPV00000000<",
4791: ">SRM;ID_FLAG=F;CS_FLAG=T;EC_FLAG=F;FR_FLAG=T;CR_FLAG=F<",
4792: ">FTM00020001<",
4793: (char *)0
4794: };
4795:
4796: static void
4797: trimbletaip_event(
4798: struct parseunit *parse,
4799: int event
4800: )
4801: {
4802: switch (event)
4803: {
4804: case CEVNT_BADREPLY: /* reset on garbled input */
4805: case CEVNT_TIMEOUT: /* reset on no input */
4806: {
4807: const char **iv;
4808:
4809: iv = taipinit;
4810: while (*iv)
4811: {
4812: int rtc = write(parse->generic->io.fd, *iv, strlen(*iv));
4813: if (rtc < 0)
4814: {
4815: msyslog(LOG_ERR, "PARSE receiver #%d: trimbletaip_event: failed to send cmd to clock: %m", CLK_UNIT(parse->peer));
4816: return;
4817: }
4818: else
4819: {
4820: if (rtc != strlen(*iv))
4821: {
4822: msyslog(LOG_ERR, "PARSE receiver #%d: trimbletaip_event: failed to send cmd incomplete (%d of %d bytes sent)",
4823: CLK_UNIT(parse->peer), rtc, (int)strlen(*iv));
4824: return;
4825: }
4826: }
4827: iv++;
4828: }
4829:
4830: NLOG(NLOG_CLOCKINFO)
4831: ERR(ERR_BADIO)
4832: msyslog(LOG_ERR, "PARSE receiver #%d: trimbletaip_event: RECEIVER INITIALIZED",
4833: CLK_UNIT(parse->peer));
4834: }
4835: break;
4836:
4837: default: /* ignore */
4838: break;
4839: }
4840: }
4841:
4842: /*
4843: * This driver supports the Trimble SVee Six Plus GPS receiver module.
4844: * It should support other Trimble receivers which use the Trimble Standard
4845: * Interface Protocol (see below).
4846: *
4847: * The module has a serial I/O port for command/data and a 1 pulse-per-second
4848: * output, about 1 microsecond wide. The leading edge of the pulse is
4849: * coincident with the change of the GPS second. This is the same as
4850: * the change of the UTC second +/- ~1 microsecond. Some other clocks
4851: * specifically use a feature in the data message as a timing reference, but
4852: * the SVee Six Plus does not do this. In fact there is considerable jitter
4853: * on the timing of the messages, so this driver only supports the use
4854: * of the PPS pulse for accurate timing. Where it is determined that
4855: * the offset is way off, when first starting up ntpd for example,
4856: * the timing of the data stream is used until the offset becomes low enough
4857: * (|offset| < CLOCK_MAX), at which point the pps offset is used.
4858: *
4859: * It can use either option for receiving PPS information - the 'ppsclock'
4860: * stream pushed onto the serial data interface to timestamp the Carrier
4861: * Detect interrupts, where the 1PPS connects to the CD line. This only
4862: * works on SunOS 4.1.x currently. To select this, define PPSPPS in
4863: * Config.local. The other option is to use a pulse-stretcher/level-converter
4864: * to convert the PPS pulse into a RS232 start pulse & feed this into another
4865: * tty port. To use this option, define PPSCLK in Config.local. The pps input,
4866: * by whichever method, is handled in ntp_loopfilter.c
4867: *
4868: * The receiver uses a serial message protocol called Trimble Standard
4869: * Interface Protocol (it can support others but this driver only supports
4870: * TSIP). Messages in this protocol have the following form:
4871: *
4872: * <DLE><id> ... <data> ... <DLE><ETX>
4873: *
4874: * Any bytes within the <data> portion of value 10 hex (<DLE>) are doubled
4875: * on transmission and compressed back to one on reception. Otherwise
4876: * the values of data bytes can be anything. The serial interface is RS-422
4877: * asynchronous using 9600 baud, 8 data bits with odd party (**note** 9 bits
4878: * in total!), and 1 stop bit. The protocol supports byte, integer, single,
4879: * and double datatypes. Integers are two bytes, sent most significant first.
4880: * Singles are IEEE754 single precision floating point numbers (4 byte) sent
4881: * sign & exponent first. Doubles are IEEE754 double precision floating point
4882: * numbers (8 byte) sent sign & exponent first.
4883: * The receiver supports a large set of messages, only a small subset of
4884: * which are used here. From driver to receiver the following are used:
4885: *
4886: * ID Description
4887: *
4888: * 21 Request current time
4889: * 22 Mode Select
4890: * 2C Set/Request operating parameters
4891: * 2F Request UTC info
4892: * 35 Set/Request I/O options
4893:
4894: * From receiver to driver the following are recognised:
4895: *
4896: * ID Description
4897: *
4898: * 41 GPS Time
4899: * 44 Satellite selection, PDOP, mode
4900: * 46 Receiver health
4901: * 4B Machine code/status
4902: * 4C Report operating parameters (debug only)
4903: * 4F UTC correction data (used to get leap second warnings)
4904: * 55 I/O options (debug only)
4905: *
4906: * All others are accepted but ignored.
4907: *
4908: */
4909:
4910: #define PI 3.1415926535898 /* lots of sig figs */
4911: #define D2R PI/180.0
4912:
4913: /*-------------------------------------------------------------------
4914: * sendcmd, sendbyte, sendetx, sendflt, sendint implement the command
4915: * interface to the receiver.
4916: *
4917: * CAVEAT: the sendflt, sendint routines are byte order dependend and
4918: * float implementation dependend - these must be converted to portable
4919: * versions !
4920: *
4921: * CURRENT LIMITATION: float implementation. This runs only on systems
4922: * with IEEE754 floats as native floats
4923: */
4924:
4925: typedef struct trimble
4926: {
4927: u_long last_msg; /* last message received */
4928: u_long last_reset; /* last time a reset was issued */
4929: u_char qtracking; /* query tracking status */
4930: u_long ctrack; /* current tracking set */
4931: u_long ltrack; /* last tracking set */
4932: } trimble_t;
4933:
4934: union uval {
4935: u_char bd[8];
4936: int iv;
4937: float fv;
4938: double dv;
4939: };
4940:
4941: struct txbuf
4942: {
4943: short idx; /* index to first unused byte */
4944: u_char *txt; /* pointer to actual data buffer */
4945: };
4946:
4947: void sendcmd (struct txbuf *buf, int c);
4948: void sendbyte (struct txbuf *buf, int b);
4949: void sendetx (struct txbuf *buf, struct parseunit *parse);
4950: void sendint (struct txbuf *buf, int a);
4951: void sendflt (struct txbuf *buf, double a);
4952:
4953: void
4954: sendcmd(
4955: struct txbuf *buf,
4956: int c
4957: )
4958: {
4959: buf->txt[0] = DLE;
4960: buf->txt[1] = (u_char)c;
4961: buf->idx = 2;
4962: }
4963:
4964: void sendcmd (struct txbuf *buf, int c);
4965: void sendbyte (struct txbuf *buf, int b);
4966: void sendetx (struct txbuf *buf, struct parseunit *parse);
4967: void sendint (struct txbuf *buf, int a);
4968: void sendflt (struct txbuf *buf, double a);
4969:
4970: void
4971: sendbyte(
4972: struct txbuf *buf,
4973: int b
4974: )
4975: {
4976: if (b == DLE)
4977: buf->txt[buf->idx++] = DLE;
4978: buf->txt[buf->idx++] = (u_char)b;
4979: }
4980:
4981: void
4982: sendetx(
4983: struct txbuf *buf,
4984: struct parseunit *parse
4985: )
4986: {
4987: buf->txt[buf->idx++] = DLE;
4988: buf->txt[buf->idx++] = ETX;
4989:
4990: if (write(parse->generic->io.fd, buf->txt, (unsigned long)buf->idx) != buf->idx)
4991: {
4992: ERR(ERR_BADIO)
4993: msyslog(LOG_ERR, "PARSE receiver #%d: sendetx: failed to send cmd to clock: %m", CLK_UNIT(parse->peer));
4994: }
4995: else
4996: {
4997: #ifdef DEBUG
4998: if (debug > 2)
4999: {
5000: char buffer[256];
5001:
5002: mkreadable(buffer, sizeof(buffer), (char *)buf->txt, (unsigned)buf->idx, 1);
5003: printf("PARSE receiver #%d: transmitted message (%d bytes) >%s<\n",
5004: CLK_UNIT(parse->peer),
5005: buf->idx, buffer);
5006: }
5007: #endif
5008: clear_err(parse, ERR_BADIO);
5009: }
5010: }
5011:
5012: void
5013: sendint(
5014: struct txbuf *buf,
5015: int a
5016: )
5017: {
5018: /* send 16bit int, msbyte first */
5019: sendbyte(buf, (u_char)((a>>8) & 0xff));
5020: sendbyte(buf, (u_char)(a & 0xff));
5021: }
5022:
5023: void
5024: sendflt(
5025: struct txbuf *buf,
5026: double a
5027: )
5028: {
5029: int i;
5030: union uval uval;
5031:
5032: uval.fv = a;
5033: #ifdef WORDS_BIGENDIAN
5034: for (i=0; i<=3; i++)
5035: #else
5036: for (i=3; i>=0; i--)
5037: #endif
5038: sendbyte(buf, uval.bd[i]);
5039: }
5040:
5041: #define TRIM_POS_OPT 0x13 /* output position with high precision */
5042: #define TRIM_TIME_OPT 0x03 /* use UTC time stamps, on second */
5043:
5044: /*--------------------------------------------------
5045: * trimble TSIP setup routine
5046: */
5047: static int
5048: trimbletsip_setup(
5049: struct parseunit *parse,
5050: const char *reason
5051: )
5052: {
5053: u_char buffer[256];
5054: struct txbuf buf;
5055: trimble_t *t = parse->localdata;
5056:
5057: if (t && t->last_reset &&
5058: ((t->last_reset + TRIMBLE_RESET_HOLDOFF) > current_time)) {
5059: return 1; /* not yet */
5060: }
5061:
5062: if (t)
5063: t->last_reset = current_time;
5064:
5065: buf.txt = buffer;
5066:
5067: sendcmd(&buf, CMD_CVERSION); /* request software versions */
5068: sendetx(&buf, parse);
5069:
5070: sendcmd(&buf, CMD_COPERPARAM); /* set operating parameters */
5071: sendbyte(&buf, 4); /* static */
5072: sendflt(&buf, 5.0*D2R); /* elevation angle mask = 10 deg XXX */
5073: sendflt(&buf, 4.0); /* s/n ratio mask = 6 XXX */
5074: sendflt(&buf, 12.0); /* PDOP mask = 12 */
5075: sendflt(&buf, 8.0); /* PDOP switch level = 8 */
5076: sendetx(&buf, parse);
5077:
5078: sendcmd(&buf, CMD_CMODESEL); /* fix mode select */
5079: sendbyte(&buf, 1); /* time transfer mode */
5080: sendetx(&buf, parse);
5081:
5082: sendcmd(&buf, CMD_CMESSAGE); /* request system message */
5083: sendetx(&buf, parse);
5084:
5085: sendcmd(&buf, CMD_CSUPER); /* superpacket fix */
5086: sendbyte(&buf, 0x2); /* binary mode */
5087: sendetx(&buf, parse);
5088:
5089: sendcmd(&buf, CMD_CIOOPTIONS); /* set I/O options */
5090: sendbyte(&buf, TRIM_POS_OPT); /* position output */
5091: sendbyte(&buf, 0x00); /* no velocity output */
5092: sendbyte(&buf, TRIM_TIME_OPT); /* UTC, compute on seconds */
5093: sendbyte(&buf, 0x00); /* no raw measurements */
5094: sendetx(&buf, parse);
5095:
5096: sendcmd(&buf, CMD_CUTCPARAM); /* request UTC correction data */
5097: sendetx(&buf, parse);
5098:
5099: NLOG(NLOG_CLOCKINFO)
5100: ERR(ERR_BADIO)
5101: msyslog(LOG_ERR, "PARSE receiver #%d: trimbletsip_setup: RECEIVER RE-INITIALIZED (%s)", CLK_UNIT(parse->peer), reason);
5102:
5103: return 0;
5104: }
5105:
5106: /*--------------------------------------------------
5107: * TRIMBLE TSIP check routine
5108: */
5109: static void
5110: trimble_check(
5111: struct peer *peer
5112: )
5113: {
5114: struct parseunit *parse = (struct parseunit *)peer->procptr->unitptr;
5115: trimble_t *t = parse->localdata;
5116: u_char buffer[256];
5117: struct txbuf buf;
5118: buf.txt = buffer;
5119:
5120: if (t)
5121: {
5122: if (current_time > t->last_msg + TRIMBLETSIP_IDLE_TIME)
5123: (void)trimbletsip_setup(parse, "message timeout");
5124: }
5125:
5126: poll_poll(parse->peer); /* emit query string and re-arm timer */
5127:
5128: if (t && t->qtracking)
5129: {
5130: u_long oldsats = t->ltrack & ~t->ctrack;
5131:
5132: t->qtracking = 0;
5133: t->ltrack = t->ctrack;
5134:
5135: if (oldsats)
5136: {
5137: int i;
5138:
5139: for (i = 0; oldsats; i++) {
5140: if (oldsats & (1 << i))
5141: {
5142: sendcmd(&buf, CMD_CSTATTRACK);
5143: sendbyte(&buf, i+1); /* old sat */
5144: sendetx(&buf, parse);
5145: }
5146: oldsats &= ~(1 << i);
5147: }
5148: }
5149:
5150: sendcmd(&buf, CMD_CSTATTRACK);
5151: sendbyte(&buf, 0x00); /* current tracking set */
5152: sendetx(&buf, parse);
5153: }
5154: }
5155:
5156: /*--------------------------------------------------
5157: * TRIMBLE TSIP end routine
5158: */
5159: static void
5160: trimbletsip_end(
5161: struct parseunit *parse
5162: )
5163: { trimble_t *t = parse->localdata;
5164:
5165: if (t)
5166: {
5167: free(t);
5168: parse->localdata = (void *)0;
5169: }
5170: parse->peer->nextaction = 0;
5171: parse->peer->action = (void (*) (struct peer *))0;
5172: }
5173:
5174: /*--------------------------------------------------
5175: * TRIMBLE TSIP init routine
5176: */
5177: static int
5178: trimbletsip_init(
5179: struct parseunit *parse
5180: )
5181: {
5182: #if defined(VEOL) || defined(VEOL2)
5183: #ifdef HAVE_TERMIOS
5184: struct termios tio; /* NEEDED FOR A LONG TIME ! */
5185: #endif
5186: #ifdef HAVE_SYSV_TTYS
5187: struct termio tio; /* NEEDED FOR A LONG TIME ! */
5188: #endif
5189: /*
5190: * allocate local data area
5191: */
5192: if (!parse->localdata)
5193: {
5194: trimble_t *t;
5195:
5196: t = (trimble_t *)(parse->localdata = emalloc(sizeof(trimble_t)));
5197:
5198: if (t)
5199: {
5200: memset((char *)t, 0, sizeof(trimble_t));
5201: t->last_msg = current_time;
5202: }
5203: }
5204:
5205: parse->peer->action = trimble_check;
5206: parse->peer->nextaction = current_time;
5207:
5208: /*
5209: * configure terminal line for ICANON mode with VEOL characters
5210: */
5211: if (TTY_GETATTR(parse->generic->io.fd, &tio) == -1)
5212: {
5213: msyslog(LOG_ERR, "PARSE receiver #%d: trimbletsip_init: tcgetattr(%d, &tio): %m", CLK_UNIT(parse->peer), parse->generic->io.fd);
5214: return 0;
5215: }
5216: else
5217: {
5218: if ((parse_clockinfo[CLK_TYPE(parse->peer)].cl_lflag & ICANON))
5219: {
5220: #ifdef VEOL
5221: tio.c_cc[VEOL] = ETX;
5222: #endif
5223: #ifdef VEOL2
5224: tio.c_cc[VEOL2] = DLE;
5225: #endif
5226: }
5227:
5228: if (TTY_SETATTR(parse->generic->io.fd, &tio) == -1)
5229: {
5230: msyslog(LOG_ERR, "PARSE receiver #%d: trimbletsip_init: tcsetattr(%d, &tio): %m", CLK_UNIT(parse->peer), parse->generic->io.fd);
5231: return 0;
5232: }
5233: }
5234: #endif
5235: return trimbletsip_setup(parse, "initial startup");
5236: }
5237:
5238: /*------------------------------------------------------------
5239: * trimbletsip_event - handle Trimble events
5240: * simple evente handler - attempt to re-initialize receiver
5241: */
5242: static void
5243: trimbletsip_event(
5244: struct parseunit *parse,
5245: int event
5246: )
5247: {
5248: switch (event)
5249: {
5250: case CEVNT_BADREPLY: /* reset on garbled input */
5251: case CEVNT_TIMEOUT: /* reset on no input */
5252: (void)trimbletsip_setup(parse, "event BAD_REPLY/TIMEOUT");
5253: break;
5254:
5255: default: /* ignore */
5256: break;
5257: }
5258: }
5259:
5260: /*
5261: * getflt, getint convert fields in the incoming data into the
5262: * appropriate type of item
5263: *
5264: * CAVEAT: these routines are currently definitely byte order dependent
5265: * and assume Representation(float) == IEEE754
5266: * These functions MUST be converted to portable versions (especially
5267: * converting the float representation into ntp_fp formats in order
5268: * to avoid floating point operations at all!
5269: */
5270:
5271: static float
5272: getflt(
5273: u_char *bp
5274: )
5275: {
5276: union uval uval;
5277:
5278: #ifdef WORDS_BIGENDIAN
5279: uval.bd[0] = *bp++;
5280: uval.bd[1] = *bp++;
5281: uval.bd[2] = *bp++;
5282: uval.bd[3] = *bp;
5283: #else /* ! WORDS_BIGENDIAN */
5284: uval.bd[3] = *bp++;
5285: uval.bd[2] = *bp++;
5286: uval.bd[1] = *bp++;
5287: uval.bd[0] = *bp;
5288: #endif /* ! WORDS_BIGENDIAN */
5289: return uval.fv;
5290: }
5291:
5292: static double
5293: getdbl(
5294: u_char *bp
5295: )
5296: {
5297: union uval uval;
5298:
5299: #ifdef WORDS_BIGENDIAN
5300: uval.bd[0] = *bp++;
5301: uval.bd[1] = *bp++;
5302: uval.bd[2] = *bp++;
5303: uval.bd[3] = *bp++;
5304: uval.bd[4] = *bp++;
5305: uval.bd[5] = *bp++;
5306: uval.bd[6] = *bp++;
5307: uval.bd[7] = *bp;
5308: #else /* ! WORDS_BIGENDIAN */
5309: uval.bd[7] = *bp++;
5310: uval.bd[6] = *bp++;
5311: uval.bd[5] = *bp++;
5312: uval.bd[4] = *bp++;
5313: uval.bd[3] = *bp++;
5314: uval.bd[2] = *bp++;
5315: uval.bd[1] = *bp++;
5316: uval.bd[0] = *bp;
5317: #endif /* ! WORDS_BIGENDIAN */
5318: return uval.dv;
5319: }
5320:
5321: static int
5322: getshort(
5323: unsigned char *p
5324: )
5325: {
5326: return get_msb_short(&p);
5327: }
5328:
5329: /*--------------------------------------------------
5330: * trimbletsip_message - process trimble messages
5331: */
5332: #define RTOD (180.0 / 3.1415926535898)
5333: #define mb(_X_) (buffer[2+(_X_)]) /* shortcut for buffer access */
5334:
5335: static void
5336: trimbletsip_message(
5337: struct parseunit *parse,
5338: parsetime_t *parsetime
5339: )
5340: {
5341: unsigned char *buffer = parsetime->parse_msg;
5342: unsigned int size = parsetime->parse_msglen;
5343:
5344: if ((size < 4) ||
5345: (buffer[0] != DLE) ||
5346: (buffer[size-1] != ETX) ||
5347: (buffer[size-2] != DLE))
5348: {
5349: #ifdef DEBUG
5350: if (debug > 2) {
5351: int i;
5352:
5353: printf("TRIMBLE BAD packet, size %d:\n ", size);
5354: for (i = 0; i < size; i++) {
5355: printf ("%2.2x, ", buffer[i]&0xff);
5356: if (i%16 == 15) printf("\n\t");
5357: }
5358: printf("\n");
5359: }
5360: #endif
5361: return;
5362: }
5363: else
5364: {
5365: int var_flag;
5366: trimble_t *tr = parse->localdata;
5367: unsigned int cmd = buffer[1];
5368: char pbuffer[200];
5369: char *t = pbuffer;
5370: cmd_info_t *s;
5371:
5372: #ifdef DEBUG
5373: if (debug > 3) {
5374: int i;
5375:
5376: printf("TRIMBLE packet 0x%02x, size %d:\n ", cmd, size);
5377: for (i = 0; i < size; i++) {
5378: printf ("%2.2x, ", buffer[i]&0xff);
5379: if (i%16 == 15) printf("\n\t");
5380: }
5381: printf("\n");
5382: }
5383: #endif
5384:
5385: if (tr)
5386: tr->last_msg = current_time;
5387:
5388: s = trimble_convert(cmd, trimble_rcmds);
5389:
5390: if (s)
5391: {
5392: snprintf(t, BUFFER_SIZE(pbuffer, t), "%s=\"", s->varname);
5393: }
5394: else
5395: {
5396: DPRINTF(1, ("TRIMBLE UNKNOWN COMMAND 0x%02x\n", cmd));
5397: return;
5398: }
5399:
5400: var_flag = s->varmode;
5401:
5402: t += strlen(t);
5403:
5404: switch(cmd)
5405: {
5406: case CMD_RCURTIME:
5407: snprintf(t, BUFFER_SIZE(pbuffer, t), "%f, %d, %f",
5408: getflt((unsigned char *)&mb(0)), getshort((unsigned char *)&mb(4)),
5409: getflt((unsigned char *)&mb(6)));
5410: break;
5411:
5412: case CMD_RBEST4:
5413: strncpy(t, "mode: ", BUFFER_SIZE(pbuffer, t));
5414: t += strlen(t);
5415: switch (mb(0) & 0xF)
5416: {
5417: default:
5418: snprintf(t, BUFFER_SIZE(pbuffer, t), "0x%x", mb(0) & 0x7);
5419: break;
5420:
5421: case 1:
5422: strncpy(t, "0D", BUFFER_SIZE(pbuffer, t));
5423: break;
5424:
5425: case 3:
5426: strncpy(t, "2D", BUFFER_SIZE(pbuffer, t));
5427: break;
5428:
5429: case 4:
5430: strncpy(t, "3D", BUFFER_SIZE(pbuffer, t));
5431: break;
5432: }
5433: t += strlen(t);
5434: if (mb(0) & 0x10)
5435: strncpy(t, "-MANUAL, ", BUFFER_SIZE(pbuffer, t));
5436: else
5437: strncpy(t, "-AUTO, ", BUFFER_SIZE(pbuffer, t));
5438: t += strlen(t);
5439:
5440: snprintf(t, BUFFER_SIZE(pbuffer, t), "satellites %02d %02d %02d %02d, PDOP %.2f, HDOP %.2f, VDOP %.2f, TDOP %.2f",
5441: mb(1), mb(2), mb(3), mb(4),
5442: getflt((unsigned char *)&mb(5)),
5443: getflt((unsigned char *)&mb(9)),
5444: getflt((unsigned char *)&mb(13)),
5445: getflt((unsigned char *)&mb(17)));
5446:
5447: break;
5448:
5449: case CMD_RVERSION:
5450: snprintf(t, BUFFER_SIZE(pbuffer, t), "%d.%d (%d/%d/%d)",
5451: mb(0)&0xff, mb(1)&0xff, 1900+(mb(4)&0xff), mb(2)&0xff, mb(3)&0xff);
5452: break;
5453:
5454: case CMD_RRECVHEALTH:
5455: {
5456: static const char *msgs[] =
5457: {
5458: "Battery backup failed",
5459: "Signal processor error",
5460: "Alignment error, channel or chip 1",
5461: "Alignment error, channel or chip 2",
5462: "Antenna feed line fault",
5463: "Excessive ref freq. error",
5464: "<BIT 6>",
5465: "<BIT 7>"
5466: };
5467:
5468: int i, bits;
5469:
5470: switch (mb(0) & 0xFF)
5471: {
5472: default:
5473: snprintf(t, BUFFER_SIZE(pbuffer, t), "illegal value 0x%02x", mb(0) & 0xFF);
5474: break;
5475: case 0x00:
5476: strncpy(t, "doing position fixes", BUFFER_SIZE(pbuffer, t));
5477: break;
5478: case 0x01:
5479: strncpy(t, "no GPS time yet", BUFFER_SIZE(pbuffer, t));
5480: break;
5481: case 0x03:
5482: strncpy(t, "PDOP too high", BUFFER_SIZE(pbuffer, t));
5483: break;
5484: case 0x08:
5485: strncpy(t, "no usable satellites", BUFFER_SIZE(pbuffer, t));
5486: break;
5487: case 0x09:
5488: strncpy(t, "only ONE usable satellite", BUFFER_SIZE(pbuffer, t));
5489: break;
5490: case 0x0A:
5491: strncpy(t, "only TWO usable satellites", BUFFER_SIZE(pbuffer, t));
5492: break;
5493: case 0x0B:
5494: strncpy(t, "only THREE usable satellites", BUFFER_SIZE(pbuffer, t));
5495: break;
5496: case 0x0C:
5497: strncpy(t, "the chosen satellite is unusable", BUFFER_SIZE(pbuffer, t));
5498: break;
5499: }
5500:
5501: t += strlen(t);
5502:
5503: bits = mb(1) & 0xFF;
5504:
5505: for (i = 0; i < 8; i++)
5506: if (bits & (0x1<<i))
5507: {
5508: snprintf(t, BUFFER_SIZE(pbuffer, t), ", %s", msgs[i]);
5509: t += strlen(t);
5510: }
5511: }
5512: break;
5513:
5514: case CMD_RMESSAGE:
5515: mkreadable(t, (int)BUFFER_SIZE(pbuffer, t), (char *)&mb(0), (unsigned)(size - 2 - (&mb(0) - buffer)), 0);
5516: break;
5517:
5518: case CMD_RMACHSTAT:
5519: {
5520: static const char *msgs[] =
5521: {
5522: "Synthesizer Fault",
5523: "Battery Powered Time Clock Fault",
5524: "A-to-D Converter Fault",
5525: "The almanac stored in the receiver is not complete and current",
5526: "<BIT 4>",
5527: "<BIT 5",
5528: "<BIT 6>",
5529: "<BIT 7>"
5530: };
5531:
5532: int i, bits;
5533:
5534: snprintf(t, BUFFER_SIZE(pbuffer, t), "machine id 0x%02x", mb(0) & 0xFF);
5535: t += strlen(t);
5536:
5537: bits = mb(1) & 0xFF;
5538:
5539: for (i = 0; i < 8; i++)
5540: if (bits & (0x1<<i))
5541: {
5542: snprintf(t, BUFFER_SIZE(pbuffer, t), ", %s", msgs[i]);
5543: t += strlen(t);
5544: }
5545:
5546: snprintf(t, BUFFER_SIZE(pbuffer, t), ", Superpackets %ssupported", (mb(2) & 0xFF) ? "" :"un" );
5547: }
5548: break;
5549:
5550: case CMD_ROPERPARAM:
5551: snprintf(t, BUFFER_SIZE(pbuffer, t), "%2x %.1f %.1f %.1f %.1f",
5552: mb(0), getflt((unsigned char *)&mb(1)), getflt((unsigned char *)&mb(5)),
5553: getflt((unsigned char *)&mb(9)), getflt((unsigned char *)&mb(13)));
5554: break;
5555:
5556: case CMD_RUTCPARAM:
5557: {
5558: float t0t = getflt((unsigned char *)&mb(14));
5559: short wnt = getshort((unsigned char *)&mb(18));
5560: short dtls = getshort((unsigned char *)&mb(12));
5561: short wnlsf = getshort((unsigned char *)&mb(20));
5562: short dn = getshort((unsigned char *)&mb(22));
5563: short dtlsf = getshort((unsigned char *)&mb(24));
5564:
5565: if ((int)t0t != 0)
5566: {
5567: mk_utcinfo(t, wnt, wnlsf, dn, dtls, dtlsf, BUFFER_SIZE(pbuffer, t));
5568: }
5569: else
5570: {
5571: strncpy(t, "<NO UTC DATA>", BUFFER_SIZE(pbuffer, t));
5572: }
5573: }
5574: break;
5575:
5576: case CMD_RSAT1BIAS:
5577: snprintf(t, BUFFER_SIZE(pbuffer, t), "%.1fm %.2fm/s at %.1fs",
5578: getflt(&mb(0)), getflt(&mb(4)), getflt(&mb(8)));
5579: break;
5580:
5581: case CMD_RIOOPTIONS:
5582: {
5583: snprintf(t, BUFFER_SIZE(pbuffer, t), "%02x %02x %02x %02x",
5584: mb(0), mb(1), mb(2), mb(3));
5585: if (mb(0) != TRIM_POS_OPT ||
5586: mb(2) != TRIM_TIME_OPT)
5587: {
5588: (void)trimbletsip_setup(parse, "bad io options");
5589: }
5590: }
5591: break;
5592:
5593: case CMD_RSPOSXYZ:
5594: {
5595: double x = getflt((unsigned char *)&mb(0));
5596: double y = getflt((unsigned char *)&mb(4));
5597: double z = getflt((unsigned char *)&mb(8));
5598: double f = getflt((unsigned char *)&mb(12));
5599:
5600: if (f > 0.0)
5601: snprintf(t, BUFFER_SIZE(pbuffer, t), "x= %.1fm, y= %.1fm, z= %.1fm, time_of_fix= %f sec",
5602: x, y, z,
5603: f);
5604: else
5605: return;
5606: }
5607: break;
5608:
5609: case CMD_RSLLAPOS:
5610: {
5611: double lat = getflt((unsigned char *)&mb(0));
5612: double lng = getflt((unsigned char *)&mb(4));
5613: double f = getflt((unsigned char *)&mb(12));
5614:
5615: if (f > 0.0)
5616: snprintf(t, BUFFER_SIZE(pbuffer, t), "lat %f %c, long %f %c, alt %.2fm",
5617: ((lat < 0.0) ? (-lat) : (lat))*RTOD, (lat < 0.0 ? 'S' : 'N'),
5618: ((lng < 0.0) ? (-lng) : (lng))*RTOD, (lng < 0.0 ? 'W' : 'E'),
5619: getflt((unsigned char *)&mb(8)));
5620: else
5621: return;
5622: }
5623: break;
5624:
5625: case CMD_RDOUBLEXYZ:
5626: {
5627: double x = getdbl((unsigned char *)&mb(0));
5628: double y = getdbl((unsigned char *)&mb(8));
5629: double z = getdbl((unsigned char *)&mb(16));
5630: snprintf(t, BUFFER_SIZE(pbuffer, t), "x= %.1fm, y= %.1fm, z= %.1fm",
5631: x, y, z);
5632: }
5633: break;
5634:
5635: case CMD_RDOUBLELLA:
5636: {
5637: double lat = getdbl((unsigned char *)&mb(0));
5638: double lng = getdbl((unsigned char *)&mb(8));
5639: snprintf(t, BUFFER_SIZE(pbuffer, t), "lat %f %c, lon %f %c, alt %.2fm",
5640: ((lat < 0.0) ? (-lat) : (lat))*RTOD, (lat < 0.0 ? 'S' : 'N'),
5641: ((lng < 0.0) ? (-lng) : (lng))*RTOD, (lng < 0.0 ? 'W' : 'E'),
5642: getdbl((unsigned char *)&mb(16)));
5643: }
5644: break;
5645:
5646: case CMD_RALLINVIEW:
5647: {
5648: int i, sats;
5649:
5650: strncpy(t, "mode: ", BUFFER_SIZE(pbuffer, t));
5651: t += strlen(t);
5652: switch (mb(0) & 0x7)
5653: {
5654: default:
5655: snprintf(t, BUFFER_SIZE(pbuffer, t), "0x%x", mb(0) & 0x7);
5656: break;
5657:
5658: case 3:
5659: strncpy(t, "2D", BUFFER_SIZE(pbuffer, t));
5660: break;
5661:
5662: case 4:
5663: strncpy(t, "3D", BUFFER_SIZE(pbuffer, t));
5664: break;
5665: }
5666: t += strlen(t);
5667: if (mb(0) & 0x8)
5668: strncpy(t, "-MANUAL, ", BUFFER_SIZE(pbuffer, t));
5669: else
5670: strncpy(t, "-AUTO, ", BUFFER_SIZE(pbuffer, t));
5671: t += strlen(t);
5672:
5673: sats = (mb(0)>>4) & 0xF;
5674:
5675: snprintf(t, BUFFER_SIZE(pbuffer, t), "PDOP %.2f, HDOP %.2f, VDOP %.2f, TDOP %.2f, %d satellite%s in view: ",
5676: getflt((unsigned char *)&mb(1)),
5677: getflt((unsigned char *)&mb(5)),
5678: getflt((unsigned char *)&mb(9)),
5679: getflt((unsigned char *)&mb(13)),
5680: sats, (sats == 1) ? "" : "s");
5681: t += strlen(t);
5682:
5683: for (i=0; i < sats; i++)
5684: {
5685: snprintf(t, BUFFER_SIZE(pbuffer, t), "%s%02d", i ? ", " : "", mb(17+i));
5686: t += strlen(t);
5687: if (tr)
5688: tr->ctrack |= (1 << (mb(17+i)-1));
5689: }
5690:
5691: if (tr)
5692: { /* mark for tracking status query */
5693: tr->qtracking = 1;
5694: }
5695: }
5696: break;
5697:
5698: case CMD_RSTATTRACK:
5699: {
5700: snprintf(t-2, BUFFER_SIZE(pbuffer, t-2), "[%02d]=\"", mb(0)); /* add index to var name */
5701: t += strlen(t);
5702:
5703: if (getflt((unsigned char *)&mb(4)) < 0.0)
5704: {
5705: strncpy(t, "<NO MEASUREMENTS>", BUFFER_SIZE(pbuffer, t));
5706: var_flag &= ~DEF;
5707: }
5708: else
5709: {
5710: snprintf(t, BUFFER_SIZE(pbuffer, t), "ch=%d, acq=%s, eph=%d, signal_level= %5.2f, elevation= %5.2f, azimuth= %6.2f",
5711: (mb(1) & 0xFF)>>3,
5712: mb(2) ? ((mb(2) == 1) ? "ACQ" : "SRCH") : "NEVER",
5713: mb(3),
5714: getflt((unsigned char *)&mb(4)),
5715: getflt((unsigned char *)&mb(12)) * RTOD,
5716: getflt((unsigned char *)&mb(16)) * RTOD);
5717: t += strlen(t);
5718: if (mb(20))
5719: {
5720: var_flag &= ~DEF;
5721: strncpy(t, ", OLD", BUFFER_SIZE(pbuffer, t));
5722: }
5723: t += strlen(t);
5724: if (mb(22))
5725: {
5726: if (mb(22) == 1)
5727: strncpy(t, ", BAD PARITY", BUFFER_SIZE(pbuffer, t));
5728: else
5729: if (mb(22) == 2)
5730: strncpy(t, ", BAD EPH HEALTH", BUFFER_SIZE(pbuffer, t));
5731: }
5732: t += strlen(t);
5733: if (mb(23))
5734: strncpy(t, ", collecting data", BUFFER_SIZE(pbuffer, t));
5735: }
5736: }
5737: break;
5738:
5739: default:
5740: strncpy(t, "<UNDECODED>", BUFFER_SIZE(pbuffer, t));
5741: break;
5742: }
5743: t += strlen(t);
5744:
5745: strncpy(t,"\"", BUFFER_SIZE(pbuffer, t));
5746: set_var(&parse->kv, pbuffer, sizeof(pbuffer), var_flag);
5747: }
5748: }
5749:
5750:
5751: /**============================================================
5752: ** RAWDCF support
5753: **/
5754:
5755: /*--------------------------------------------------
5756: * rawdcf_init_1 - set up modem lines for RAWDCF receivers
5757: * SET DTR line
5758: */
5759: #if defined(TIOCMSET) && (defined(TIOCM_DTR) || defined(CIOCM_DTR))
5760: static int
5761: rawdcf_init_1(
5762: struct parseunit *parse
5763: )
5764: {
5765: /* fixed 2000 for using with Linux by Wolfram Pienkoss <wp@bszh.de> */
5766: /*
5767: * You can use the RS232 to supply the power for a DCF77 receiver.
5768: * Here a voltage between the DTR and the RTS line is used. Unfortunately
5769: * the name has changed from CIOCM_DTR to TIOCM_DTR recently.
5770: */
5771: int sl232;
5772:
5773: if (ioctl(parse->generic->io.fd, TIOCMGET, (caddr_t)&sl232) == -1)
5774: {
5775: msyslog(LOG_NOTICE, "PARSE receiver #%d: rawdcf_init_1: WARNING: ioctl(fd, TIOCMGET, [C|T]IOCM_DTR): %m", CLK_UNIT(parse->peer));
5776: return 0;
5777: }
5778:
5779: #ifdef TIOCM_DTR
5780: sl232 = (sl232 & ~TIOCM_RTS) | TIOCM_DTR; /* turn on DTR, clear RTS for power supply */
5781: #else
5782: sl232 = (sl232 & ~CIOCM_RTS) | CIOCM_DTR; /* turn on DTR, clear RTS for power supply */
5783: #endif
5784:
5785: if (ioctl(parse->generic->io.fd, TIOCMSET, (caddr_t)&sl232) == -1)
5786: {
5787: msyslog(LOG_NOTICE, "PARSE receiver #%d: rawdcf_init_1: WARNING: ioctl(fd, TIOCMSET, [C|T]IOCM_DTR): %m", CLK_UNIT(parse->peer));
5788: }
5789: return 0;
5790: }
5791: #else
5792: static int
5793: rawdcfdtr_init_1(
5794: struct parseunit *parse
5795: )
5796: {
5797: msyslog(LOG_NOTICE, "PARSE receiver #%d: rawdcf_init_1: WARNING: OS interface incapable of setting DTR to power DCF modules", CLK_UNIT(parse->peer));
5798: return 0;
5799: }
5800: #endif /* DTR initialisation type */
5801:
5802: /*--------------------------------------------------
5803: * rawdcf_init_2 - set up modem lines for RAWDCF receivers
5804: * CLR DTR line, SET RTS line
5805: */
5806: #if defined(TIOCMSET) && (defined(TIOCM_RTS) || defined(CIOCM_RTS))
5807: static int
5808: rawdcf_init_2(
5809: struct parseunit *parse
5810: )
5811: {
5812: /* fixed 2000 for using with Linux by Wolfram Pienkoss <wp@bszh.de> */
5813: /*
5814: * You can use the RS232 to supply the power for a DCF77 receiver.
5815: * Here a voltage between the DTR and the RTS line is used. Unfortunately
5816: * the name has changed from CIOCM_DTR to TIOCM_DTR recently.
5817: */
5818: int sl232;
5819:
5820: if (ioctl(parse->generic->io.fd, TIOCMGET, (caddr_t)&sl232) == -1)
5821: {
5822: msyslog(LOG_NOTICE, "PARSE receiver #%d: rawdcf_init_2: WARNING: ioctl(fd, TIOCMGET, [C|T]IOCM_RTS): %m", CLK_UNIT(parse->peer));
5823: return 0;
5824: }
5825:
5826: #ifdef TIOCM_RTS
5827: sl232 = (sl232 & ~TIOCM_DTR) | TIOCM_RTS; /* turn on RTS, clear DTR for power supply */
5828: #else
5829: sl232 = (sl232 & ~CIOCM_DTR) | CIOCM_RTS; /* turn on RTS, clear DTR for power supply */
5830: #endif
5831:
5832: if (ioctl(parse->generic->io.fd, TIOCMSET, (caddr_t)&sl232) == -1)
5833: {
5834: msyslog(LOG_NOTICE, "PARSE receiver #%d: rawdcf_init_2: WARNING: ioctl(fd, TIOCMSET, [C|T]IOCM_RTS): %m", CLK_UNIT(parse->peer));
5835: }
5836: return 0;
5837: }
5838: #else
5839: static int
5840: rawdcf_init_2(
5841: struct parseunit *parse
5842: )
5843: {
5844: msyslog(LOG_NOTICE, "PARSE receiver #%d: rawdcf_init_2: WARNING: OS interface incapable of setting RTS to power DCF modules", CLK_UNIT(parse->peer));
5845: return 0;
5846: }
5847: #endif /* DTR initialisation type */
5848:
5849: #else /* defined(REFCLOCK) && defined(PARSE) */
5850: int refclock_parse_bs;
5851: #endif /* defined(REFCLOCK) && defined(PARSE) */
5852:
5853: /*
5854: * History:
5855: *
5856: * refclock_parse.c,v
5857: * Revision 4.81 2009/05/01 10:15:29 kardel
5858: * use new refclock_ppsapi interface
5859: *
5860: * Revision 4.80 2007/08/11 12:06:29 kardel
5861: * update comments wrt/ to PPS
5862: *
5863: * Revision 4.79 2007/08/11 11:52:23 kardel
5864: * - terminate io bindings before io_closeclock() will close our file descriptor
5865: *
5866: * Revision 4.78 2006/12/22 20:08:27 kardel
5867: * Bug 746 (RFE): add configuration for Expert mouseCLOCK USB v2.0 as mode 19
5868: *
5869: * Revision 4.77 2006/08/05 07:44:49 kardel
5870: * support optionally separate PPS devices via /dev/refclockpps-{0..3}
5871: *
5872: * Revision 4.76 2006/06/22 18:40:47 kardel
5873: * clean up signedness (gcc 4)
5874: *
5875: * Revision 4.75 2006/06/22 16:58:10 kardel
5876: * Bug #632: call parse_ppsapi() in parse_ctl() when updating
5877: * the PPS offset. Fix sign of offset passed to kernel.
5878: *
5879: * Revision 4.74 2006/06/18 21:18:37 kardel
5880: * NetBSD Coverity CID 3796: possible NULL deref
5881: *
5882: * Revision 4.73 2006/05/26 14:23:46 kardel
5883: * cleanup of copyright info
5884: *
5885: * Revision 4.72 2006/05/26 14:19:43 kardel
5886: * cleanup of ioctl cruft
5887: *
5888: * Revision 4.71 2006/05/26 14:15:57 kardel
5889: * delay adding refclock to async refclock io after all initializations
5890: *
5891: * Revision 4.70 2006/05/25 18:20:50 kardel
5892: * bug #619
5893: * terminate parse io engine after de-registering
5894: * from refclock io engine
5895: *
5896: * Revision 4.69 2006/05/25 17:28:02 kardel
5897: * complete refclock io structure initialization *before* inserting it into the
5898: * refclock input machine (avoids null pointer deref) (bug #619)
5899: *
5900: * Revision 4.68 2006/05/01 17:02:51 kardel
5901: * copy receiver method also for newlwy created receive buffers
5902: *
5903: * Revision 4.67 2006/05/01 14:37:29 kardel
5904: * If an input buffer parses into more than one message do insert the
5905: * parsed message in a new input buffer instead of processing it
5906: * directly. This avoids deed complicated processing in signal
5907: * handling.
5908: *
5909: * Revision 4.66 2006/03/18 00:45:30 kardel
5910: * coverity fixes found in NetBSD coverity scan
5911: *
5912: * Revision 4.65 2006/01/26 06:08:33 kardel
5913: * output errno on PPS setup failure
5914: *
5915: * Revision 4.64 2005/11/09 20:44:47 kardel
5916: * utilize full PPS timestamp resolution from PPS API
5917: *
5918: * Revision 4.63 2005/10/07 22:10:25 kardel
5919: * bounded buffer implementation
5920: *
5921: * Revision 4.62.2.2 2005/09/25 10:20:16 kardel
5922: * avoid unexpected buffer overflows due to sprintf("%f") on strange floats:
5923: * replace almost all str* and *printf functions be their buffer bounded
5924: * counterparts
5925: *
5926: * Revision 4.62.2.1 2005/08/27 16:19:27 kardel
5927: * limit re-set rate of trimble clocks
5928: *
5929: * Revision 4.62 2005/08/06 17:40:00 kardel
5930: * cleanup size handling wrt/ to buffer boundaries
5931: *
5932: * Revision 4.61 2005/07/27 21:16:19 kardel
5933: * fix a long (> 11 years) misconfiguration wrt/ Meinberg cflag factory
5934: * default setup. CSTOPB was missing for the 7E2 default data format of
5935: * the DCF77 clocks.
5936: *
5937: * Revision 4.60 2005/07/17 21:14:44 kardel
5938: * change contents of version string to include the RCS/CVS Id
5939: *
5940: * Revision 4.59 2005/07/06 06:56:38 kardel
5941: * syntax error
5942: *
5943: * Revision 4.58 2005/07/04 13:10:40 kardel
5944: * fix bug 455: tripping over NULL pointer on cleanup
5945: * fix shadow storage logic for ppsphaseadjust and trustime wrt/ time2
5946: * fix compiler warnings for some platforms wrt/ printf formatstrings and
5947: * varying structure element sizes
5948: * reorder assignment in binding to avoid tripping over NULL pointers
5949: *
5950: * Revision 4.57 2005/06/25 09:25:19 kardel
5951: * sort out log output sequence
5952: *
5953: * Revision 4.56 2005/06/14 21:47:27 kardel
5954: * collect samples only if samples are ok (sync or trusted flywheel)
5955: * propagate pps phase adjustment value to kernel via PPSAPI to help HARDPPS
5956: * en- and dis-able HARDPPS in correlation to receiver sync state
5957: *
5958: * Revision 4.55 2005/06/02 21:28:31 kardel
5959: * clarify trust logic
5960: *
5961: * Revision 4.54 2005/06/02 17:06:49 kardel
5962: * change status reporting to use fixed refclock_report()
5963: *
5964: * Revision 4.53 2005/06/02 16:33:31 kardel
5965: * fix acceptance of clocks unsync clocks right at start
5966: *
5967: * Revision 4.52 2005/05/26 21:55:06 kardel
5968: * cleanup status reporting
5969: *
5970: * Revision 4.51 2005/05/26 19:19:14 kardel
5971: * implement fast refclock startup
5972: *
5973: * Revision 4.50 2005/04/16 20:51:35 kardel
5974: * set pps_enable = 1 when binding a kernel PPS source
5975: *
5976: * Revision 4.49 2005/04/16 17:29:26 kardel
5977: * add non polling clock type 18 for just listenning to Meinberg clocks
5978: *
5979: * Revision 4.48 2005/04/16 16:22:27 kardel
5980: * bk sync 20050415 ntp-dev
5981: *
5982: * Revision 4.47 2004/11/29 10:42:48 kardel
5983: * bk sync ntp-dev 20041129
5984: *
5985: * Revision 4.46 2004/11/29 10:26:29 kardel
5986: * keep fudgetime2 in sync with trusttime/ppsphaseadjust depending in flag1
5987: *
5988: * Revision 4.45 2004/11/14 20:53:20 kardel
5989: * clear PPS flags after using them
5990: *
5991: * Revision 4.44 2004/11/14 15:29:41 kardel
5992: * support PPSAPI, upgrade Copyright to Berkeley style
5993: *
5994: * Revision 4.43 2001/05/26 22:53:16 kardel
5995: * 20010526 reconcilation
5996: *
5997: * Revision 4.42 2000/05/14 15:31:51 kardel
5998: * PPSAPI && RAWDCF modemline support
5999: *
6000: * Revision 4.41 2000/04/09 19:50:45 kardel
6001: * fixed rawdcfdtr_init() -> rawdcf_init_1
6002: *
6003: * Revision 4.40 2000/04/09 15:27:55 kardel
6004: * modem line fiddle in rawdcf_init_2
6005: *
6006: * Revision 4.39 2000/03/18 09:16:55 kardel
6007: * PPSAPI integration
6008: *
6009: * Revision 4.38 2000/03/05 20:25:06 kardel
6010: * support PPSAPI
6011: *
6012: * Revision 4.37 2000/03/05 20:11:14 kardel
6013: * 4.0.99g reconcilation
6014: *
6015: * Revision 4.36 1999/11/28 17:18:20 kardel
6016: * disabled burst mode
6017: *
6018: * Revision 4.35 1999/11/28 09:14:14 kardel
6019: * RECON_4_0_98F
6020: *
6021: * Revision 4.34 1999/05/14 06:08:05 kardel
6022: * store current_time in a suitable container (u_long)
6023: *
6024: * Revision 4.33 1999/05/13 21:48:38 kardel
6025: * double the no response timeout interval
6026: *
6027: * Revision 4.32 1999/05/13 20:09:13 kardel
6028: * complain only about missing polls after a full poll interval
6029: *
6030: * Revision 4.31 1999/05/13 19:59:32 kardel
6031: * add clock type 16 for RTS set DTR clr in RAWDCF
6032: *
6033: * Revision 4.30 1999/02/28 20:36:43 kardel
6034: * fixed printf fmt
6035: *
6036: * Revision 4.29 1999/02/28 19:58:23 kardel
6037: * updated copyright information
6038: *
6039: * Revision 4.28 1999/02/28 19:01:50 kardel
6040: * improved debug out on sent Meinberg messages
6041: *
6042: * Revision 4.27 1999/02/28 18:05:55 kardel
6043: * no linux/ppsclock.h stuff
6044: *
6045: * Revision 4.26 1999/02/28 15:27:27 kardel
6046: * wharton clock integration
6047: *
6048: * Revision 4.25 1999/02/28 14:04:46 kardel
6049: * added missing double quotes to UTC information string
6050: *
6051: * Revision 4.24 1999/02/28 12:06:50 kardel
6052: * (parse_control): using gmprettydate instead of prettydate()
6053: * (mk_utcinfo): new function for formatting GPS derived UTC information
6054: * (gps16x_message): changed to use mk_utcinfo()
6055: * (trimbletsip_message): changed to use mk_utcinfo()
6056: * ignoring position information in unsynchronized mode
6057: * (parse_start): augument linux support for optional ASYNC_LOW_LATENCY
6058: *
6059: * Revision 4.23 1999/02/23 19:47:53 kardel
6060: * fixed #endifs
6061: * (stream_receive): fixed formats
6062: *
6063: * Revision 4.22 1999/02/22 06:21:02 kardel
6064: * use new autoconfig symbols
6065: *
6066: * Revision 4.21 1999/02/21 12:18:13 kardel
6067: * 4.91f reconcilation
6068: *
6069: * Revision 4.20 1999/02/21 10:53:36 kardel
6070: * initial Linux PPSkit version
6071: *
6072: * Revision 4.19 1999/02/07 09:10:45 kardel
6073: * clarify STREAMS mitigation rules in comment
6074: *
6075: * Revision 4.18 1998/12/20 23:45:34 kardel
6076: * fix types and warnings
6077: *
6078: * Revision 4.17 1998/11/15 21:24:51 kardel
6079: * cannot access mbg_ routines when CLOCK_MEINBERG
6080: * is not defined
6081: *
6082: * Revision 4.16 1998/11/15 20:28:17 kardel
6083: * Release 4.0.73e13 reconcilation
6084: *
6085: * Revision 4.15 1998/08/22 21:56:08 kardel
6086: * fixed IO handling for non-STREAM IO
6087: *
6088: * Revision 4.14 1998/08/16 19:00:48 kardel
6089: * (gps16x_message): reduced UTC parameter information (dropped A0,A1)
6090: * made uval a local variable (killed one of the last globals)
6091: * (sendetx): added logging of messages when in debug mode
6092: * (trimble_check): added periodic checks to facilitate re-initialization
6093: * (trimbletsip_init): made use of EOL character if in non-kernel operation
6094: * (trimbletsip_message): extended message interpretation
6095: * (getdbl): fixed data conversion
6096: *
6097: * Revision 4.13 1998/08/09 22:29:13 kardel
6098: * Trimble TSIP support
6099: *
6100: * Revision 4.12 1998/07/11 10:05:34 kardel
6101: * Release 4.0.73d reconcilation
6102: *
6103: * Revision 4.11 1998/06/14 21:09:42 kardel
6104: * Sun acc cleanup
6105: *
6106: * Revision 4.10 1998/06/13 12:36:45 kardel
6107: * signed/unsigned, name clashes
6108: *
6109: * Revision 4.9 1998/06/12 15:30:00 kardel
6110: * prototype fixes
6111: *
6112: * Revision 4.8 1998/06/12 11:19:42 kardel
6113: * added direct input processing routine for refclocks in
6114: * order to avaiod that single character io gobbles up all
6115: * receive buffers and drops input data. (Problem started
6116: * with fast machines so a character a buffer was possible
6117: * one of the few cases where faster machines break existing
6118: * allocation algorithms)
6119: *
6120: * Revision 4.7 1998/06/06 18:35:20 kardel
6121: * (parse_start): added BURST mode initialisation
6122: *
6123: * Revision 4.6 1998/05/27 06:12:46 kardel
6124: * RAWDCF_BASEDELAY default added
6125: * old comment removed
6126: * casts for ioctl()
6127: *
6128: * Revision 4.5 1998/05/25 22:05:09 kardel
6129: * RAWDCF_SETDTR option removed
6130: * clock type 14 attempts to set DTR for
6131: * power supply of RAWDCF receivers
6132: *
6133: * Revision 4.4 1998/05/24 16:20:47 kardel
6134: * updated comments referencing Meinberg clocks
6135: * added RAWDCF clock with DTR set option as type 14
6136: *
6137: * Revision 4.3 1998/05/24 10:48:33 kardel
6138: * calibrated CONRAD RAWDCF default fudge factor
6139: *
6140: * Revision 4.2 1998/05/24 09:59:35 kardel
6141: * corrected version information (ntpq support)
6142: *
6143: * Revision 4.1 1998/05/24 09:52:31 kardel
6144: * use fixed format only (new IO model)
6145: * output debug to stdout instead of msyslog()
6146: * don't include >"< in ASCII output in order not to confuse
6147: * ntpq parsing
6148: *
6149: * Revision 4.0 1998/04/10 19:52:11 kardel
6150: * Start 4.0 release version numbering
6151: *
6152: * Revision 1.2 1998/04/10 19:28:04 kardel
6153: * initial NTP VERSION 4 integration of PARSE with GPS166 binary support
6154: * derived from 3.105.1.2 from V3 tree
6155: *
6156: * Revision information 3.1 - 3.105 from log deleted 1998/04/10 kardel
6157: *
6158: */