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