dist/ntp/libparse/clk_rawdcf.c

   1 /*      $NetBSD: clk_rawdcf.c,v 1.4 2006/06/11 19:34:10 kardel Exp $    */
   2
   3 /*
   4  * /src/NTP/REPOSITORY/ntp4-dev/libparse/clk_rawdcf.c,v 4.18 2006/06/22 18:40:01 kardel RELEASE_20060622_A
   5  *
   6  * clk_rawdcf.c,v 4.18 2006/06/22 18:40:01 kardel RELEASE_20060622_A
   7  *
   8  * Raw DCF77 pulse clock support
   9  *
  10  * Copyright (c) 1995-2006 by Frank Kardel <kardel <AT> ntp.org>
  11  * Copyright (c) 1989-1994 by Frank Kardel, Friedrich-Alexander Universität Erlangen-Nürnberg, Germany
  12  *
  13  * Redistribution and use in source and binary forms, with or without
  14  * modification, are permitted provided that the following conditions
  15  * are met:
  16  * 1. Redistributions of source code must retain the above copyright
  17  *    notice, this list of conditions and the following disclaimer.
  18  * 2. Redistributions in binary form must reproduce the above copyright
  19  *    notice, this list of conditions and the following disclaimer in the
  20  *    documentation and/or other materials provided with the distribution.
  21  * 3. Neither the name of the author nor the names of its contributors
  22  *    may be used to endorse or promote products derived from this software
  23  *    without specific prior written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  35  * SUCH DAMAGE.
  36  *
  37  */
  38
  39 #ifdef HAVE_CONFIG_H
  40 # include <config.h>
  41 #endif
  42
  43 #if defined(REFCLOCK) && defined(CLOCK_PARSE) && defined(CLOCK_RAWDCF)
  44
  45 #include "ntp_fp.h"
  46 #include "ntp_unixtime.h"
  47 #include "ntp_calendar.h"
  48
  49 #include "parse.h"
  50 #ifdef PARSESTREAM
  51 # include <sys/parsestreams.h>
  52 #endif
  53
  54 #ifndef PARSEKERNEL
  55 # include "ntp_stdlib.h"
  56 #endif
  57
  58 /*
  59  * DCF77 raw time code
  60  *
  61  * From "Zur Zeit", Physikalisch-Technische Bundesanstalt (PTB), Braunschweig
  62  * und Berlin, Maerz 1989
  63  *
  64  * Timecode transmission:
  65  * AM:
  66  *      time marks are send every second except for the second before the
  67  *      next minute mark
  68  *      time marks consist of a reduction of transmitter power to 25%
  69  *      of the nominal level
  70  *      the falling edge is the time indication (on time)
  71  *      time marks of a 100ms duration constitute a logical 0
  72  *      time marks of a 200ms duration constitute a logical 1
  73  * FM:
  74  *      see the spec. (basically a (non-)inverted psuedo random phase shift)
  75  *
  76  * Encoding:
  77  * Second       Contents
  78  * 0  - 10      AM: free, FM: 0
  79  * 11 - 14      free
  80  * 15           R     - alternate antenna
  81  * 16           A1    - expect zone change (1 hour before)
  82  * 17 - 18      Z1,Z2 - time zone
  83  *               0  0 illegal
  84  *               0  1 MEZ  (MET)
  85  *               1  0 MESZ (MED, MET DST)
  86  *               1  1 illegal
  87  * 19           A2    - expect leap insertion/deletion (1 hour before)
  88  * 20           S     - start of time code (1)
  89  * 21 - 24      M1    - BCD (lsb first) Minutes
  90  * 25 - 27      M10   - BCD (lsb first) 10 Minutes
  91  * 28           P1    - Minute Parity (even)
  92  * 29 - 32      H1    - BCD (lsb first) Hours
  93  * 33 - 34      H10   - BCD (lsb first) 10 Hours
  94  * 35           P2    - Hour Parity (even)
  95  * 36 - 39      D1    - BCD (lsb first) Days
  96  * 40 - 41      D10   - BCD (lsb first) 10 Days
  97  * 42 - 44      DW    - BCD (lsb first) day of week (1: Monday -> 7: Sunday)
  98  * 45 - 49      MO    - BCD (lsb first) Month
  99  * 50           MO0   - 10 Months
 100  * 51 - 53      Y1    - BCD (lsb first) Years
 101  * 54 - 57      Y10   - BCD (lsb first) 10 Years
 102  * 58           P3    - Date Parity (even)
 103  * 59                 - usually missing (minute indication), except for leap insertion
 104  */
 105
 106 static u_long pps_rawdcf P((parse_t *, int, timestamp_t *));
 107 static u_long cvt_rawdcf P((unsigned char *, int, struct format *, clocktime_t *, void *));
 108 static u_long inp_rawdcf P((parse_t *, unsigned int, timestamp_t  *));
 109
 110 typedef struct last_tcode {
 111         time_t tcode;   /* last converted time code */
 112 } last_tcode_t;
 113
 114 #define BUFFER_MAX      61
 115
 116 clockformat_t clock_rawdcf =
 117 {
 118   inp_rawdcf,                   /* DCF77 input handling */
 119   cvt_rawdcf,                   /* raw dcf input conversion */
 120   pps_rawdcf,                   /* examining PPS information */
 121   0,                            /* no private configuration data */
 122   "RAW DCF77 Timecode",         /* direct decoding / time synthesis */
 123
 124   BUFFER_MAX,                   /* bit buffer */
 125   sizeof(last_tcode_t)
 126 };
 127
 128 static struct dcfparam
 129 {
 130         unsigned char *onebits;
 131         unsigned char *zerobits;
 132 } dcfparameter =
 133 {
 134         (unsigned char *)"###############RADMLS1248124P124812P1248121241248112481248P??", /* 'ONE' representation */
 135         (unsigned char *)"--------------------s-------p------p----------------------p__"  /* 'ZERO' representation */
 136 };
 137
 138 static struct rawdcfcode
 139 {
 140         char offset;                    /* start bit */
 141 } rawdcfcode[] =
 142 {
 143         {  0 }, { 15 }, { 16 }, { 17 }, { 19 }, { 20 }, { 21 }, { 25 }, { 28 }, { 29 },
 144         { 33 }, { 35 }, { 36 }, { 40 }, { 42 }, { 45 }, { 49 }, { 50 }, { 54 }, { 58 }, { 59 }
 145 };
 146
 147 #define DCF_M   0
 148 #define DCF_R   1
 149 #define DCF_A1  2
 150 #define DCF_Z   3
 151 #define DCF_A2  4
 152 #define DCF_S   5
 153 #define DCF_M1  6
 154 #define DCF_M10 7
 155 #define DCF_P1  8
 156 #define DCF_H1  9
 157 #define DCF_H10 10
 158 #define DCF_P2  11
 159 #define DCF_D1  12
 160 #define DCF_D10 13
 161 #define DCF_DW  14
 162 #define DCF_MO  15
 163 #define DCF_MO0 16
 164 #define DCF_Y1  17
 165 #define DCF_Y10 18
 166 #define DCF_P3  19
 167
 168 static struct partab
 169 {
 170         char offset;                    /* start bit of parity field */
 171 } partab[] =
 172 {
 173         { 21 }, { 29 }, { 36 }, { 59 }
 174 };
 175
 176 #define DCF_P_P1        0
 177 #define DCF_P_P2        1
 178 #define DCF_P_P3        2
 179
 180 #define DCF_Z_MET 0x2
 181 #define DCF_Z_MED 0x1
 182
 183 static u_long
 184 ext_bf(
 185         unsigned char *buf,
 186         int   idx,
 187         unsigned char *zero
 188         )
 189 {
 190         u_long sum = 0;
 191         int i, first;
 192
 193         first = rawdcfcode[idx].offset;
 194
 195         for (i = rawdcfcode[idx+1].offset - 1; i >= first; i--)
 196         {
 197                 sum <<= 1;
 198                 sum |= (buf[i] != zero[i]);
 199         }
 200         return sum;
 201 }
 202
 203 static unsigned
 204 pcheck(
 205        unsigned char *buf,
 206        int   idx,
 207        unsigned char *zero
 208        )
 209 {
 210         int i,last;
 211         unsigned psum = 1;
 212
 213         last = partab[idx+1].offset;
 214
 215         for (i = partab[idx].offset; i < last; i++)
 216             psum ^= (buf[i] != zero[i]);
 217
 218         return psum;
 219 }
 220
 221 static u_long
 222 convert_rawdcf(
 223                unsigned char   *buffer,
 224                int              size,
 225                struct dcfparam *dcfprm,
 226                clocktime_t     *clock_time
 227                )
 228 {
 229         unsigned char *s = buffer;
 230         unsigned char *b = dcfprm->onebits;
 231         unsigned char *c = dcfprm->zerobits;
 232         int i;
 233
 234         parseprintf(DD_RAWDCF,("parse: convert_rawdcf: \"%s\"\n", buffer));
 235
 236         if (size < 57)
 237         {
 238 #ifndef PARSEKERNEL
 239                 msyslog(LOG_ERR, "parse: convert_rawdcf: INCOMPLETE DATA - time code only has %d bits\n", size);
 240 #endif
 241                 return CVT_NONE;
 242         }
 243
 244         for (i = 0; i < size; i++)
 245         {
 246                 if ((*s != *b) && (*s != *c))
 247                 {
 248                         /*
 249                          * we only have two types of bytes (ones and zeros)
 250                          */
 251 #ifndef PARSEKERNEL
 252                         msyslog(LOG_ERR, "parse: convert_rawdcf: BAD DATA - no conversion");
 253 #endif
 254                         return CVT_NONE;
 255                 }
 256                 if (*b) b++;
 257                 if (*c) c++;
 258                 s++;
 259         }
 260
 261         /*
 262          * check Start and Parity bits
 263          */
 264         if ((ext_bf(buffer, DCF_S, dcfprm->zerobits) == 1) &&
 265             pcheck(buffer, DCF_P_P1, dcfprm->zerobits) &&
 266             pcheck(buffer, DCF_P_P2, dcfprm->zerobits) &&
 267             pcheck(buffer, DCF_P_P3, dcfprm->zerobits))
 268         {
 269                 /*
 270                  * buffer OK
 271                  */
 272                 parseprintf(DD_RAWDCF,("parse: convert_rawdcf: parity check passed\n"));
 273
 274                 clock_time->flags  = PARSEB_S_ANTENNA|PARSEB_S_LEAP;
 275                 clock_time->utctime= 0;
 276                 clock_time->usecond= 0;
 277                 clock_time->second = 0;
 278                 clock_time->minute = ext_bf(buffer, DCF_M10, dcfprm->zerobits);
 279                 clock_time->minute = TIMES10(clock_time->minute) + ext_bf(buffer, DCF_M1, dcfprm->zerobits);
 280                 clock_time->hour   = ext_bf(buffer, DCF_H10, dcfprm->zerobits);
 281                 clock_time->hour   = TIMES10(clock_time->hour) + ext_bf(buffer, DCF_H1, dcfprm->zerobits);
 282                 clock_time->day    = ext_bf(buffer, DCF_D10, dcfprm->zerobits);
 283                 clock_time->day    = TIMES10(clock_time->day) + ext_bf(buffer, DCF_D1, dcfprm->zerobits);
 284                 clock_time->month  = ext_bf(buffer, DCF_MO0, dcfprm->zerobits);
 285                 clock_time->month  = TIMES10(clock_time->month) + ext_bf(buffer, DCF_MO, dcfprm->zerobits);
 286                 clock_time->year   = ext_bf(buffer, DCF_Y10, dcfprm->zerobits);
 287                 clock_time->year   = TIMES10(clock_time->year) + ext_bf(buffer, DCF_Y1, dcfprm->zerobits);
 288
 289                 switch (ext_bf(buffer, DCF_Z, dcfprm->zerobits))
 290                 {
 291                     case DCF_Z_MET:
 292                         clock_time->utcoffset = -1*60*60;
 293                         break;
 294
 295                     case DCF_Z_MED:
 296                         clock_time->flags     |= PARSEB_DST;
 297                         clock_time->utcoffset  = -2*60*60;
 298                         break;
 299
 300                     default:
 301                         parseprintf(DD_RAWDCF,("parse: convert_rawdcf: BAD TIME ZONE\n"));
 302                         return CVT_FAIL|CVT_BADFMT;
 303                 }
 304
 305                 if (ext_bf(buffer, DCF_A1, dcfprm->zerobits))
 306                     clock_time->flags |= PARSEB_ANNOUNCE;
 307
 308                 if (ext_bf(buffer, DCF_A2, dcfprm->zerobits))
 309                     clock_time->flags |= PARSEB_LEAPADD; /* default: DCF77 data format deficiency */
 310
 311                 if (ext_bf(buffer, DCF_R, dcfprm->zerobits))
 312                     clock_time->flags |= PARSEB_ALTERNATE;
 313
 314                 parseprintf(DD_RAWDCF,("parse: convert_rawdcf: TIME CODE OK: %d:%d, %d.%d.%d, flags 0x%lx\n",
 315                                        (int)clock_time->hour, (int)clock_time->minute, (int)clock_time->day, (int)clock_time->month,(int) clock_time->year,
 316                                        (u_long)clock_time->flags));
 317                 return CVT_OK;
 318         }
 319         else
 320         {
 321                 /*
 322                  * bad format - not for us
 323                  */
 324 #ifndef PARSEKERNEL
 325                 msyslog(LOG_ERR, "parse: convert_rawdcf: parity check FAILED for \"%s\"\n", buffer);
 326 #endif
 327                 return CVT_FAIL|CVT_BADFMT;
 328         }
 329 }
 330
 331 /*
 332  * raw dcf input routine - needs to fix up 50 baud
 333  * characters for 1/0 decision
 334  */
 335 static u_long
 336 cvt_rawdcf(
 337            unsigned char   *buffer,
 338            int              size,
 339            struct format   *param,
 340            clocktime_t     *clock_time,
 341            void            *local
 342            )
 343 {
 344         last_tcode_t  *t = (last_tcode_t *)local;
 345         unsigned char *s = (unsigned char *)buffer;
 346         unsigned char *e = s + size;
 347         unsigned char *b = dcfparameter.onebits;
 348         unsigned char *c = dcfparameter.zerobits;
 349         u_long       rtc = CVT_NONE;
 350         unsigned int i, lowmax, highmax, cutoff, span;
 351 #define BITS 9
 352         unsigned char     histbuf[BITS];
 353         /*
 354          * the input buffer contains characters with runs of consecutive
 355          * bits set. These set bits are an indication of the DCF77 pulse
 356          * length. We assume that we receive the pulse at 50 Baud. Thus
 357          * a 100ms pulse would generate a 4 bit train (20ms per bit and
 358          * start bit)
 359          * a 200ms pulse would create all zeroes (and probably a frame error)
 360          */
 361
 362         for (i = 0; i < BITS; i++)
 363         {
 364                 histbuf[i] = 0;
 365         }
 366
 367         cutoff = 0;
 368         lowmax = 0;
 369
 370         while (s < e)
 371         {
 372                 unsigned int ch = *s ^ 0xFF;
 373                 /*
 374                  * these lines are left as an excercise to the reader 8-)
 375                  */
 376                 if (!((ch+1) & ch) || !*s)
 377                 {
 378
 379                         for (i = 0; ch; i++)
 380                         {
 381                                 ch >>= 1;
 382                         }
 383
 384                         *s = i;
 385                         histbuf[i]++;
 386                         cutoff += i;
 387                         lowmax++;
 388                 }
 389                 else
 390                 {
 391                         parseprintf(DD_RAWDCF,("parse: cvt_rawdcf: character check for 0x%x@%d FAILED\n", *s, (int)(s - (unsigned char *)buffer)));
 392                         *s = (unsigned char)~0;
 393                         rtc = CVT_FAIL|CVT_BADFMT;
 394                 }
 395                 s++;
 396         }
 397
 398         if (lowmax)
 399         {
 400                 cutoff /= lowmax;
 401         }
 402         else
 403         {
 404                 cutoff = 4;     /* doesn't really matter - it'll fail anyway, but gives error output */
 405         }
 406
 407         parseprintf(DD_RAWDCF,("parse: cvt_rawdcf: average bit count: %d\n", cutoff));
 408
 409         lowmax = 0;
 410         highmax = 0;
 411
 412         parseprintf(DD_RAWDCF,("parse: cvt_rawdcf: histogram:"));
 413         for (i = 0; i <= cutoff; i++)
 414         {
 415                 lowmax+=histbuf[i] * i;
 416                 highmax += histbuf[i];
 417                 parseprintf(DD_RAWDCF,(" %d", histbuf[i]));
 418         }
 419         parseprintf(DD_RAWDCF, (" <M>"));
 420
 421         lowmax += highmax / 2;
 422
 423         if (highmax)
 424         {
 425                 lowmax /= highmax;
 426         }
 427         else
 428         {
 429                 lowmax = 0;
 430         }
 431
 432         highmax = 0;
 433         cutoff = 0;
 434
 435         for (; i < BITS; i++)
 436         {
 437                 highmax+=histbuf[i] * i;
 438                 cutoff +=histbuf[i];
 439                 parseprintf(DD_RAWDCF,(" %d", histbuf[i]));
 440         }
 441         parseprintf(DD_RAWDCF,("\n"));
 442
 443         if (cutoff)
 444         {
 445                 highmax /= cutoff;
 446         }
 447         else
 448         {
 449                 highmax = BITS-1;
 450         }
 451
 452         span = cutoff = lowmax;
 453         for (i = lowmax; i <= highmax; i++)
 454         {
 455                 if (histbuf[cutoff] > histbuf[i])
 456                 {
 457                         cutoff = i;
 458                         span = i;
 459                 }
 460                 else
 461                     if (histbuf[cutoff] == histbuf[i])
 462                     {
 463                             span = i;
 464                     }
 465         }
 466
 467         cutoff = (cutoff + span) / 2;
 468
 469         parseprintf(DD_RAWDCF,("parse: cvt_rawdcf: lower maximum %d, higher maximum %d, cutoff %d\n", lowmax, highmax, cutoff));
 470
 471         s = (unsigned char *)buffer;
 472         while (s < e)
 473         {
 474                 if (*s == (unsigned char)~0)
 475                 {
 476                         *s = '?';
 477                 }
 478                 else
 479                 {
 480                         *s = (*s >= cutoff) ? *b : *c;
 481                 }
 482                 s++;
 483                 if (*b) b++;
 484                 if (*c) c++;
 485         }
 486
 487         if (rtc == CVT_NONE)
 488         {
 489                rtc = convert_rawdcf(buffer, size, &dcfparameter, clock_time);
 490                if (rtc == CVT_OK)
 491                {
 492                         time_t newtime;
 493
 494                         newtime = parse_to_unixtime(clock_time, &rtc);
 495                         if ((rtc == CVT_OK) && t)
 496                         {
 497                                 if ((newtime - t->tcode) == 60) /* guard against multi bit errors */
 498                                 {
 499                                         clock_time->utctime = newtime;
 500                                 }
 501                                 else
 502                                 {
 503                                         rtc = CVT_FAIL|CVT_BADTIME;
 504                                 }
 505                                 t->tcode            = newtime;
 506                         }
 507                }
 508         }
 509
 510         return rtc;
 511 }
 512
 513 /*
 514  * pps_rawdcf
 515  *
 516  * currently a very stupid version - should be extended to decode
 517  * also ones and zeros (which is easy)
 518  */
 519 /*ARGSUSED*/
 520 static u_long
 521 pps_rawdcf(
 522         parse_t *parseio,
 523         int status,
 524         timestamp_t *ptime
 525         )
 526 {
 527         if (!status)            /* negative edge for simpler wiring (Rx->DCD) */
 528         {
 529                 parseio->parse_dtime.parse_ptime  = *ptime;
 530                 parseio->parse_dtime.parse_state |= PARSEB_PPS|PARSEB_S_PPS;
 531         }
 532
 533         return CVT_NONE;
 534 }
 535
 536 static u_long
 537 snt_rawdcf(
 538         parse_t *parseio,
 539         timestamp_t *ptime
 540         )
 541 {
 542         if ((parseio->parse_dtime.parse_status & CVT_MASK) == CVT_OK)
 543         {
 544                 parseio->parse_dtime.parse_stime = *ptime;
 545
 546 #ifdef PARSEKERNEL
 547                 parseio->parse_dtime.parse_time.tv.tv_sec++;
 548 #else
 549                 parseio->parse_dtime.parse_time.fp.l_ui++;
 550 #endif
 551
 552                 parseprintf(DD_RAWDCF,("parse: snt_rawdcf: time stamp synthesized offset %d seconds\n", parseio->parse_index - 1));
 553
 554                 return updatetimeinfo(parseio, parseio->parse_lstate);
 555         }
 556         return CVT_NONE;
 557 }
 558
 559 /*
 560  * inp_rawdcf
 561  *
 562  * grab DCF77 data from input stream
 563  */
 564 static u_long
 565 inp_rawdcf(
 566           parse_t      *parseio,
 567           unsigned int  ch,
 568           timestamp_t  *tstamp
 569           )
 570 {
 571         static struct timeval timeout = { 1, 500000 }; /* 1.5 secongs denote second #60 */
 572
 573         parseprintf(DD_PARSE, ("inp_rawdcf(0x%lx, 0x%x, ...)\n", (long)parseio, ch));
 574
 575         parseio->parse_dtime.parse_stime = *tstamp; /* collect timestamp */
 576
 577         if (parse_timedout(parseio, tstamp, &timeout))
 578         {
 579                 parseprintf(DD_PARSE, ("inp_rawdcf: time out seen\n"));
 580
 581                 (void) parse_end(parseio);
 582                 (void) parse_addchar(parseio, ch);
 583                 return PARSE_INP_TIME;
 584         }
 585         else
 586         {
 587                 unsigned int rtc;
 588
 589                 rtc = parse_addchar(parseio, ch);
 590                 if (rtc == PARSE_INP_SKIP)
 591                 {
 592                         if (snt_rawdcf(parseio, tstamp) == CVT_OK)
 593                                 return PARSE_INP_SYNTH;
 594                 }
 595                 return rtc;
 596         }
 597 }
 598
 599 #else /* not (REFCLOCK && CLOCK_PARSE && CLOCK_RAWDCF) */
 600 int clk_rawdcf_bs;
 601 #endif /* not (REFCLOCK && CLOCK_PARSE && CLOCK_RAWDCF) */
 602
 603 /*
 604  * History:
 605  *
 606  * clk_rawdcf.c,v
 607  * Revision 4.18  2006/06/22 18:40:01  kardel
 608  * clean up signedness (gcc 4)
 609  *
 610  * Revision 4.17  2006/01/22 16:01:55  kardel
 611  * update version information
 612  *
 613  * Revision 4.16  2006/01/22 15:51:22  kardel
 614  * generate reasonable timecode output on invalid input
 615  *
 616  * Revision 4.15  2005/08/06 19:17:06  kardel
 617  * clean log output
 618  *
 619  * Revision 4.14  2005/08/06 17:39:40  kardel
 620  * cleanup size handling wrt/ to buffer boundaries
 621  *
 622  * Revision 4.13  2005/04/16 17:32:10  kardel
 623  * update copyright
 624  *
 625  * Revision 4.12  2004/11/14 15:29:41  kardel
 626  * support PPSAPI, upgrade Copyright to Berkeley style
 627  *
 628  * Revision 4.9  1999/12/06 13:42:23  kardel
 629  * transfer correctly converted time codes always into tcode
 630  *
 631  * Revision 4.8  1999/11/28 09:13:50  kardel
 632  * RECON_4_0_98F
 633  *
 634  * Revision 4.7  1999/04/01 20:07:20  kardel
 635  * added checking for minutie increment of timestamps in clk_rawdcf.c
 636  *
 637  * Revision 4.6  1998/06/14 21:09:37  kardel
 638  * Sun acc cleanup
 639  *
 640  * Revision 4.5  1998/06/13 12:04:16  kardel
 641  * fix SYSV clock name clash
 642  *
 643  * Revision 4.4  1998/06/12 15:22:28  kardel
 644  * fix prototypes
 645  *
 646  * Revision 4.3  1998/06/06 18:33:36  kardel
 647  * simplified condidional compile expression
 648  *
 649  * Revision 4.2  1998/05/24 11:04:18  kardel
 650  * triggering PPS on negative edge for simpler wiring (Rx->DCD)
 651  *
 652  * Revision 4.1  1998/05/24 09:39:53  kardel
 653  * implementation of the new IO handling model
 654  *
 655  * Revision 4.0  1998/04/10 19:45:30  kardel
 656  * Start 4.0 release version numbering
 657  *
 658  * from V3 3.24 log info deleted 1998/04/11 kardel
 659  *
 660  */