contrib/ntp/ntpd/refclock_bancomm.c

   1 /* refclock_bancomm.c - clock driver for the  Datum/Bancomm bc635VME
   2  * Time and Frequency Processor. It requires the BANCOMM bc635VME/
   3  * bc350VXI Time and Frequency Processor Module Driver for SunOS4.x
   4  * and SunOS5.x UNIX Systems. It has been tested on a UltraSparc
   5  * IIi-cEngine running Solaris 2.6.
   6  *
   7  * Author(s):   Ganesh Ramasivan & Gary Cliff, Computing Devices Canada,
   8  *              Ottawa, Canada
   9  *
  10  * Date:        July 1999
  11  *
  12  * Note(s):     The refclock type has been defined as 16.
  13  *
  14  *              This program has been modelled after the Bancomm driver
  15  *              originally written by R. Schmidt of Time Service, U.S.
  16  *              Naval Observatory for a HP-UX machine. Since the original
  17  *              authors no longer plan to maintain this code, all
  18  *              references to the HP-UX vme2 driver subsystem bave been
  19  *              removed. Functions vme_report_event(), vme_receive(),
  20  *              vme_control() and vme_buginfo() have been deleted because
  21  *              they are no longer being used.
  22  *
  23  *      04/28/2005 Rob Neal
  24  *              Modified to add support for Symmetricom bc637PCI-U Time &
  25  *              Frequency Processor.
  26  *      2/21/2007 Ali Ghorashi
  27  *              Modified to add support for Symmetricom bc637PCI-U Time &
  28  *              Frequency Processor on Solaris.
  29  *              Tested on Solaris 10 with a bc635 card.
  30  *
  31  *              Card bus type (VME/VXI or PCI) and environment are specified via the
  32  *              "mode" keyword on the server command in ntp.conf.
  33  *              server 127.127.16.u prefer mode M
  34  *              where u is the id (usually 0) of the entry in /dev (/dev/stfp0)
  35  *
  36  *              and M is one of the following modes:
  37  *              1               : FreeBSD PCI 635/637.
  38  *              2               : Linux or Windows PCI 635/637.
  39  *              3               : Solaris PCI 635/637
  40  *              not specified, or other number:
  41  *                              : Assumed to be VME/VXI legacy Bancomm card on Solaris.
  42  *              Linux and Windows platforms require Symmetricoms' proprietary driver
  43  *              for the TFP card.
  44  *              Solaris requires Symmetricom's driver and its header file (freely distributed) to
  45  *              be installed and running.
  46  */
  47
  48 #ifdef HAVE_CONFIG_H
  49 #include <config.h>
  50 #endif
  51
  52 #if defined(REFCLOCK) && defined(CLOCK_BANC)
  53
  54 #include "ntpd.h"
  55 #include "ntp_io.h"
  56 #include "ntp_refclock.h"
  57 #include "ntp_unixtime.h"
  58 #include "ntp_stdlib.h"
  59
  60 #include <stdio.h>
  61 #include <syslog.h>
  62 #include <ctype.h>
  63 #ifdef HAVE_SYS_IOCTL_H
  64 # include <sys/ioctl.h>
  65 #endif
  66
  67 struct btfp_time                /* Structure for reading 5 time words   */
  68                                 /* in one ioctl(2) operation.           */
  69 {
  70         unsigned short btfp_time[5];  /* Time words 0,1,2,3, and 4. (16bit)*/
  71 };
  72 /* SunOS5 ioctl commands definitions.*/
  73 #define BTFPIOC            ( 'b'<< 8 )
  74 #define IOCIO( l, n )      ( BTFPIOC | n )
  75 #define IOCIOR( l, n, s )  ( BTFPIOC | n )
  76 #define IOCIORN( l, n, s ) ( BTFPIOC | n )
  77 #define IOCIOWN( l, n, s ) ( BTFPIOC | n )
  78
  79 /***** Simple ioctl commands *****/
  80 #define RUNLOCK         IOCIOR(b, 19, int )  /* Release Capture Lockout */
  81 #define RCR0            IOCIOR(b, 22, int )  /* Read control register zero.*/
  82 #define WCR0            IOCIOWN(b, 23, int)  /* Write control register zero*/
  83 /***** Compound ioctl commands *****/
  84
  85 /* Read all 5 time words in one call.   */
  86 #if defined(__FreeBSD__)
  87 # define READTIME       _IOR('u', 5, struct btfp_time )
  88 #else
  89 # define READTIME       IOCIORN(b, 32, sizeof( struct btfp_time ))
  90 #endif
  91
  92 /* Solaris specific section */
  93 struct  stfp_tm {
  94         int32_t tm_sec;
  95         int32_t tm_min;
  96         int32_t tm_hour;
  97         int32_t tm_mday;
  98         int32_t tm_mon;
  99         int32_t tm_year;
 100         int32_t tm_wday;
 101         int32_t tm_yday;
 102         int32_t tm_isdst;
 103 };
 104
 105 struct stfp_time {
 106         struct stfp_tm  tm;
 107         int32_t         usec;                   /* usec 0 - 999999 */
 108         int32_t         hnsec;                  /* hnsec 0 - 9 (hundreds of nsecs) */
 109         int32_t         status;
 110 };
 111
 112 #define SELTIMEFORMAT   2
 113 #       define TIME_DECIMAL 0
 114 #       define TIME_BINARY      1
 115
 116 #if defined(__sun__)
 117 #undef  READTIME
 118 #define READTIME                9
 119 #endif /** __sun___ **/
 120 /* end solaris specific section */
 121
 122 struct vmedate {                           /* structure returned by get_vmetime.c */
 123         unsigned short year;
 124         unsigned short day;
 125         unsigned short hr;
 126         unsigned short mn;
 127         unsigned short sec;
 128         long frac;
 129         unsigned short status;
 130 };
 131
 132 typedef void *SYMMT_PCI_HANDLE;
 133
 134 /*
 135  * VME interface parameters.
 136  */
 137 #define VMEPRECISION    (-21)   /* precision assumed (1 us) */
 138 #define USNOREFID       "BTFP"  /* or whatever */
 139 #define VMEREFID        "BTFP"  /* reference id */
 140 #define VMEDESCRIPTION  "Bancomm bc635 TFP" /* who we are */
 141 #define VMEHSREFID      0x7f7f1000 /* 127.127.16.00 refid hi strata */
 142 /* clock type 16 is used here  */
 143 #define GMT             0       /* hour offset from Greenwich */
 144
 145 /*
 146  * Imported from ntp_timer module
 147  */
 148 extern u_long current_time;     /* current time(s) */
 149
 150 /*
 151  * VME unit control structure.
 152  * Changes made to vmeunit structure. Most members are now available in the
 153  * new refclockproc structure in ntp_refclock.h - 07/99 - Ganesh Ramasivan
 154  */
 155 struct vmeunit {
 156         struct vmedate vmedata; /* data returned from vme read */
 157         u_long lasttime;        /* last time clock heard from */
 158 };
 159
 160 /*
 161  * Function prototypes
 162  */
 163 static  int     vme_start       (int, struct peer *);
 164 static  void    vme_shutdown    (int, struct peer *);
 165 static  void    vme_receive     (struct recvbuf *);
 166 static  void    vme_poll        (int unit, struct peer *);
 167 struct vmedate *get_datumtime(struct vmedate *);
 168 void    tvme_fill(struct vmedate *, uint32_t btm[2]);
 169 void    stfp_time2tvme(struct vmedate *time_vme, struct stfp_time *stfp);
 170 static const char *get_devicename(int n);
 171
 172 /* [Bug 3558] and [Bug 1674]  perlinger@ntp.org says:
 173  *
 174  * bcReadBinTime() is defined to use two DWORD pointers on Windows and
 175  * Linux in the BANCOMM SDK.  DWORD is of course Windows-specific
 176  * (*shudder*), and it is defined as 'unsigned long' under
 177  * Linux/Unix. (*sigh*)
 178  *
 179  * This creates quite some headache.  The size of 'unsigned long' is
 180  * platform/compiler/memory-model dependent (LP32 vs LP64 vs LLP64),
 181  * while the card itself always creates 32bit time stamps.  What a
 182  * bummer.  And DWORD has tendency to contain 64bit on Win64 (which is
 183  * why we have a DWORD32 defined on Win64) so it can be used as
 184  * substitute for 'UINT_PTR' in Windows API headers.  I won't even try
 185  * to comment on that, because anything I have to say will not be civil.
 186  *
 187  * We work around this by possibly using a wrapper function that makes
 188  * the necessary conversions/casts.  It might be a bit tricky to
 189  * maintain the conditional logic below, but any lingering disease needs
 190  * constant care to avoid a breakout.
 191  */
 192 #if defined(__linux__)
 193   typedef unsigned long bcBinTimeT;
 194 # if SIZEOF_LONG == 4
 195 #   define safeReadBinTime bcReadBinTime
 196 # endif
 197 #elif defined(SYS_WINNT)
 198   typedef DWORD bcBinTimeT;
 199 # if !defined(_WIN64) || _WIN64 == 0
 200 #   define safeReadBinTime bcReadBinTime
 201 # endif
 202 #else
 203   typedef uint32_t bcBinTimeT;
 204 # define safeReadBinTime bcReadBinTime
 205 #endif
 206
 207 /*
 208  * Define the bc*() functions as weak so we can compile/link without them.
 209  * Only clients with the card will have the proprietary vendor device driver
 210  * and interface library needed for use on Linux/Windows platforms.
 211  */
 212 extern uint32_t __attribute__ ((weak)) bcReadBinTime(SYMMT_PCI_HANDLE, bcBinTimeT*, bcBinTimeT*, uint8_t*);
 213 extern SYMMT_PCI_HANDLE __attribute__ ((weak)) bcStartPci(void);
 214 extern void __attribute__ ((weak)) bcStopPci(SYMMT_PCI_HANDLE);
 215
 216 /* This is the conversion wrapper for the long/DWORD/uint32_t clash in
 217  * reading binary times.
 218  */
 219 #ifndef safeReadBinTime
 220 static uint32_t
 221 safeReadBinTime(
 222         SYMMT_PCI_HANDLE hnd,
 223         uint32_t        *pt1,
 224         uint32_t        *pt2,
 225         uint8_t         *p3
 226         )
 227 {
 228         bcBinTimeT t1, t2;
 229         uint32_t   rc;
 230
 231         rc = bcReadBinTime(hnd, &t1, &t2, p3);
 232         if (rc != 0) {
 233                 *pt1 = (uint32_t)t1;
 234                 *pt2 = (uint32_t)t2;
 235         }
 236         return rc;
 237 }
 238 #endif /* !defined(safeReadBinTime) */
 239
 240 /*
 241  * Transfer vector
 242  */
 243 struct  refclock refclock_bancomm = {
 244         vme_start,              /* start up driver */
 245         vme_shutdown,           /* shut down driver */
 246         vme_poll,               /* transmit poll message */
 247         noentry,                /* not used (old vme_control) */
 248         noentry,                /* initialize driver */
 249         noentry,                /* not used (old vme_buginfo) */
 250         NOFLAGS                 /* not used */
 251 };
 252
 253 int fd_vme;  /* file descriptor for ioctls */
 254 int regvalue;
 255 int tfp_type;   /* mode selector, indicate platform and driver interface */
 256 SYMMT_PCI_HANDLE stfp_handle;
 257
 258 /* This helper function returns the device name based on the platform we
 259  * are running on and the device number.
 260  *
 261  * Uses a static buffer, so the result is valid only to the next call of
 262  * this function!
 263  */
 264 static const char*
 265 get_devicename(int n)
 266 {
 267
 268 #   if defined(__sun__)
 269         static const char * const template ="/dev/stfp%d";
 270 #   else
 271         static const char * const template ="/dev/btfp%d";
 272 #   endif
 273         static char namebuf[20];
 274
 275         snprintf(namebuf, sizeof(namebuf), template, n);
 276         namebuf[sizeof(namebuf)-1] = '\0'; /* paranoia rulez! */
 277         return namebuf;
 278 }
 279
 280 /*
 281  * vme_start - open the VME device and initialize data for processing
 282  */
 283 static int
 284 vme_start(
 285         int unit,
 286         struct peer *peer
 287         )
 288 {
 289         register struct vmeunit *vme;
 290         struct refclockproc *pp;
 291         int dummy;
 292         char vmedev[20];
 293
 294         tfp_type = (int)(peer->ttl);
 295         switch (tfp_type) {
 296                 case 1:
 297                 case 3:
 298                         break;
 299                 case 2:
 300                         stfp_handle = bcStartPci();     /* init the card in lin/win */
 301                         break;
 302                 default:
 303                         break;
 304         }
 305         /*
 306          * Open VME device
 307          */
 308 #ifdef DEBUG
 309
 310         printf("Opening DATUM DEVICE %s\n",get_devicename(peer->refclkunit));
 311 #endif
 312         if ( (fd_vme = open(get_devicename(peer->refclkunit), O_RDWR)) < 0) {
 313                 msyslog(LOG_ERR, "vme_start: failed open of %s: %m", vmedev);
 314                 return (0);
 315         }
 316         else  {
 317                 switch (tfp_type) {
 318                         case 1: break;
 319                         case 2: break;
 320                         case 3:break;
 321                         default:
 322                                 /* Release capture lockout in case it was set before. */
 323                                 if( ioctl( fd_vme, RUNLOCK, &dummy ) )
 324                                 msyslog(LOG_ERR, "vme_start: RUNLOCK failed %m");
 325
 326                                 regvalue = 0; /* More esoteric stuff to do... */
 327                                 if( ioctl( fd_vme, WCR0, &regvalue ) )
 328                                 msyslog(LOG_ERR, "vme_start: WCR0 failed %m");
 329                                 break;
 330                 }
 331         }
 332
 333         /*
 334          * Allocate unit structure
 335          */
 336         vme = emalloc_zero(sizeof(struct vmeunit));
 337
 338
 339         /*
 340          * Set up the structures
 341          */
 342         pp = peer->procptr;
 343         pp->unitptr = vme;
 344         pp->timestarted = current_time;
 345
 346         pp->io.clock_recv = vme_receive;
 347         pp->io.srcclock = peer;
 348         pp->io.datalen = 0;
 349         pp->io.fd = fd_vme;
 350         /* shouldn't there be an io_addclock() call? */
 351
 352         /*
 353          * All done.  Initialize a few random peer variables, then
 354          * return success. Note that root delay and root dispersion are
 355          * always zero for this clock.
 356          */
 357         peer->precision = VMEPRECISION;
 358         memcpy(&pp->refid, USNOREFID,4);
 359         return (1);
 360 }
 361
 362
 363 /*
 364  * vme_shutdown - shut down a VME clock
 365  */
 366 static void
 367 vme_shutdown(
 368         int unit,
 369         struct peer *peer
 370         )
 371 {
 372         register struct vmeunit *vme;
 373         struct refclockproc *pp;
 374
 375         /*
 376          * Tell the I/O module to turn us off.  We're history.
 377          */
 378         pp = peer->procptr;
 379         vme = pp->unitptr;
 380         io_closeclock(&pp->io);
 381         pp->unitptr = NULL;
 382         if (NULL != vme)
 383                 free(vme);
 384         if (tfp_type == 2)
 385                 bcStopPci(stfp_handle);
 386 }
 387
 388
 389 /*
 390  * vme_receive - receive data from the VME device.
 391  *
 392  * Note: This interface would be interrupt-driven. We don't use that
 393  * now, but include a dummy routine for possible future adventures.
 394  */
 395 static void
 396 vme_receive(
 397         struct recvbuf *rbufp
 398         )
 399 {
 400 }
 401
 402
 403 /*
 404  * vme_poll - called by the transmit procedure
 405  */
 406 static void
 407 vme_poll(
 408         int unit,
 409         struct peer *peer
 410         )
 411 {
 412         struct vmedate *tptr;
 413         struct vmeunit *vme;
 414         struct refclockproc *pp;
 415         time_t tloc;
 416         struct tm *tadr;
 417
 418         pp = peer->procptr;
 419         vme = pp->unitptr;        /* Here is the structure */
 420
 421         tptr = &vme->vmedata;
 422         if ((tptr = get_datumtime(tptr)) == NULL ) {
 423                 refclock_report(peer, CEVNT_BADREPLY);
 424                 return;
 425         }
 426
 427         get_systime(&pp->lastrec);
 428         pp->polls++;
 429         vme->lasttime = current_time;
 430
 431         /*
 432          * Get VME time and convert to timestamp format.
 433          * The year must come from the system clock.
 434          */
 435
 436           time(&tloc);
 437           tadr = gmtime(&tloc);
 438           tptr->year = (unsigned short)(tadr->tm_year + 1900);
 439
 440         snprintf(pp->a_lastcode,
 441                  sizeof(pp->a_lastcode),
 442                  "%3.3d %2.2d:%2.2d:%2.2d.%.6ld %1d",
 443                  tptr->day,
 444                  tptr->hr,
 445                  tptr->mn,
 446                  tptr->sec,
 447                  tptr->frac,
 448                  tptr->status);
 449
 450         pp->lencode = (u_short) strlen(pp->a_lastcode);
 451
 452         pp->day =  tptr->day;
 453         pp->hour =   tptr->hr;
 454         pp->minute =  tptr->mn;
 455         pp->second =  tptr->sec;
 456         pp->nsec =   tptr->frac;
 457
 458 #ifdef DEBUG
 459         if (debug)
 460             printf("pp: %3d %02d:%02d:%02d.%06ld %1x\n",
 461                    pp->day, pp->hour, pp->minute, pp->second,
 462                    pp->nsec, tptr->status);
 463 #endif
 464         if (tptr->status ) {       /*  Status 0 is locked to ref., 1 is not */
 465                 refclock_report(peer, CEVNT_BADREPLY);
 466                 return;
 467         }
 468
 469         /*
 470          * Now, compute the reference time value. Use the heavy
 471          * machinery for the seconds and the millisecond field for the
 472          * fraction when present. If an error in conversion to internal
 473          * format is found, the program declares bad data and exits.
 474          * Note that this code does not yet know how to do the years and
 475          * relies on the clock-calendar chip for sanity.
 476          */
 477         if (!refclock_process(pp)) {
 478                 refclock_report(peer, CEVNT_BADTIME);
 479                 return;
 480         }
 481         pp->lastref = pp->lastrec;
 482         refclock_receive(peer);
 483         record_clock_stats(&peer->srcadr, pp->a_lastcode);
 484 }
 485
 486 struct vmedate *
 487 get_datumtime(struct vmedate *time_vme)
 488 {
 489         char cbuf[7];
 490         struct btfp_time vts;
 491         uint32_t btm[2];
 492         uint8_t dmy;
 493         struct stfp_time stfpm;
 494
 495         if (time_vme == NULL)
 496                 time_vme = emalloc(sizeof(*time_vme));
 497
 498         switch (tfp_type) {
 499                 case 1:                         /* BSD, PCI, 2 32bit time words */
 500                         if (ioctl(fd_vme, READTIME, &btm)) {
 501                         msyslog(LOG_ERR, "get_bc63x error: %m");
 502                                 return(NULL);
 503                         }
 504                         tvme_fill(time_vme, btm);
 505                         break;
 506
 507                 case 2:                         /* Linux/Windows, PCI, 2 32bit time words */
 508                         if (safeReadBinTime(stfp_handle, &btm[1], &btm[0], &dmy) == 0) {
 509                         msyslog(LOG_ERR, "get_datumtime error: %m");
 510                                 return(NULL);
 511                         }
 512                         tvme_fill(time_vme, btm);
 513                         break;
 514
 515                 case 3: /** solaris **/
 516                         memset(&stfpm,0,sizeof(stfpm));
 517
 518                         /* we need the time in decimal format */
 519                         /* Here we rudely assume that we are the only user of the driver.
 520                          * Other programs will have to set their own time format before reading
 521                          * the time.
 522                          */
 523                         if(ioctl (fd_vme, SELTIMEFORMAT, TIME_DECIMAL)){
 524                                         msyslog(LOG_ERR, "Could not set time format");
 525                                         return (NULL);
 526                         }
 527                         /* read the time */
 528                         if (ioctl(fd_vme, READTIME, &stfpm)) {
 529                                 msyslog(LOG_ERR, "ioctl error: %m");
 530                                 return(NULL);
 531                         }
 532                         stfp_time2tvme(time_vme,  &stfpm);
 533                         break;
 534
 535                 default:                        /* legacy bancomm card */
 536
 537                         if (ioctl(fd_vme, READTIME, &vts)) {
 538                                 msyslog(LOG_ERR,
 539                                         "get_datumtime error: %m");
 540                                 return(NULL);
 541                         }
 542                         /* Get day */
 543                         snprintf(cbuf, sizeof(cbuf), "%3.3x",
 544                                  ((vts.btfp_time[ 0 ] & 0x000f) << 8) +
 545                                   ((vts.btfp_time[ 1 ] & 0xff00) >> 8));
 546                         time_vme->day = (unsigned short)atoi(cbuf);
 547
 548                         /* Get hour */
 549                         snprintf(cbuf, sizeof(cbuf), "%2.2x",
 550                                  vts.btfp_time[ 1 ] & 0x00ff);
 551                         time_vme->hr = (unsigned short)atoi(cbuf);
 552
 553                         /* Get minutes */
 554                         snprintf(cbuf, sizeof(cbuf), "%2.2x",
 555                                  (vts.btfp_time[ 2 ] & 0xff00) >> 8);
 556                         time_vme->mn = (unsigned short)atoi(cbuf);
 557
 558                         /* Get seconds */
 559                         snprintf(cbuf, sizeof(cbuf), "%2.2x",
 560                                  vts.btfp_time[ 2 ] & 0x00ff);
 561                         time_vme->sec = (unsigned short)atoi(cbuf);
 562
 563                         /* Get microseconds.  Yes, we ignore the 0.1 microsecond digit so
 564                                  we can use the TVTOTSF function  later on...*/
 565
 566                         snprintf(cbuf, sizeof(cbuf), "%4.4x%2.2x",
 567                                  vts.btfp_time[ 3 ],
 568                                  vts.btfp_time[ 4 ] >> 8);
 569                         time_vme->frac = (u_long) atoi(cbuf);
 570
 571                         /* Get status bit */
 572                         time_vme->status = (vts.btfp_time[0] & 0x0010) >> 4;
 573
 574                         break;
 575         }
 576
 577         if (time_vme->status)
 578                 return ((void *)NULL);
 579         else
 580             return (time_vme);
 581 }
 582 /* Assign values to time_vme struct. Mostly for readability */
 583 void
 584 tvme_fill(struct vmedate *time_vme, uint32_t btm[2])
 585 {
 586         struct tm maj;
 587         time_t   dmaj;
 588         uint32_t dmin;
 589
 590         dmaj = btm[1];                  /* syntax sugar & expansion */
 591         dmin = btm[0];                  /* just syntax sugar */
 592
 593         gmtime_r(&dmaj, &maj);
 594         time_vme->day  = maj.tm_yday+1;
 595         time_vme->hr   = maj.tm_hour;
 596         time_vme->mn   = maj.tm_min;
 597         time_vme->sec  = maj.tm_sec;
 598         time_vme->frac = (dmin & 0x000fffff) * 1000;
 599         time_vme->frac += ((dmin & 0x00f00000) >> 20) * 100;
 600         time_vme->status = (dmin & 0x01000000) >> 24;
 601         return;
 602 }
 603
 604
 605 /* Assign values to time_vme struct. Mostly for readability */
 606 void
 607 stfp_time2tvme(struct vmedate *time_vme, struct stfp_time *stfp)
 608 {
 609
 610         time_vme->day  = stfp->tm.tm_yday+1;
 611         time_vme->hr   = stfp->tm.tm_hour;
 612         time_vme->mn   = stfp->tm.tm_min;
 613         time_vme->sec  = stfp->tm.tm_sec;
 614         time_vme->frac = stfp->usec*1000;
 615         time_vme->frac += stfp->hnsec * 100;
 616         time_vme->status = stfp->status;
 617         return;
 618 }
 619 #else
 620 int refclock_bancomm_bs;
 621 #endif /* REFCLOCK */