Annotation of embedaddon/ntp/ntpd/refclock_bancomm.c, revision 1.1
1.1 ! misho 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:
! 64: struct btfp_time /* Structure for reading 5 time words */
! 65: /* in one ioctl(2) operation. */
! 66: {
! 67: unsigned short btfp_time[5]; /* Time words 0,1,2,3, and 4. (16bit)*/
! 68: };
! 69: /* SunOS5 ioctl commands definitions.*/
! 70: #define BTFPIOC ( 'b'<< 8 )
! 71: #define IOCIO( l, n ) ( BTFPIOC | n )
! 72: #define IOCIOR( l, n, s ) ( BTFPIOC | n )
! 73: #define IOCIORN( l, n, s ) ( BTFPIOC | n )
! 74: #define IOCIOWN( l, n, s ) ( BTFPIOC | n )
! 75:
! 76: /***** Simple ioctl commands *****/
! 77: #define RUNLOCK IOCIOR(b, 19, int ) /* Release Capture Lockout */
! 78: #define RCR0 IOCIOR(b, 22, int ) /* Read control register zero.*/
! 79: #define WCR0 IOCIOWN(b, 23, int) /* Write control register zero*/
! 80: /***** Compound ioctl commands *****/
! 81:
! 82: /* Read all 5 time words in one call. */
! 83: #define READTIME IOCIORN(b, 32, sizeof( struct btfp_time ))
! 84:
! 85: #if defined(__FreeBSD__)
! 86: #undef READTIME
! 87: #define READTIME _IOR('u', 5, struct btfp_time )
! 88: #endif
! 89:
! 90: /* Solaris specific section */
! 91: struct stfp_tm {
! 92: int32_t tm_sec;
! 93: int32_t tm_min;
! 94: int32_t tm_hour;
! 95: int32_t tm_mday;
! 96: int32_t tm_mon;
! 97: int32_t tm_year;
! 98: int32_t tm_wday;
! 99: int32_t tm_yday;
! 100: int32_t tm_isdst;
! 101: };
! 102:
! 103: struct stfp_time {
! 104: struct stfp_tm tm;
! 105: int32_t usec; /* usec 0 - 999999 */
! 106: int32_t hnsec; /* hnsec 0 - 9 (hundreds of nsecs) */
! 107: int32_t status;
! 108: };
! 109:
! 110: #define SELTIMEFORMAT 2
! 111: # define TIME_DECIMAL 0
! 112: # define TIME_BINARY 1
! 113:
! 114: #if defined(__sun__)
! 115: #undef READTIME
! 116: #define READTIME 9
! 117: #endif /** __sun___ **/
! 118: /* end solaris specific section */
! 119:
! 120: struct vmedate { /* structure returned by get_vmetime.c */
! 121: unsigned short year;
! 122: unsigned short day;
! 123: unsigned short hr;
! 124: unsigned short mn;
! 125: unsigned short sec;
! 126: long frac;
! 127: unsigned short status;
! 128: };
! 129:
! 130: typedef void *SYMMT_PCI_HANDLE;
! 131:
! 132: /*
! 133: * VME interface parameters.
! 134: */
! 135: #define VMEPRECISION (-21) /* precision assumed (1 us) */
! 136: #define USNOREFID "BTFP" /* or whatever */
! 137: #define VMEREFID "BTFP" /* reference id */
! 138: #define VMEDESCRIPTION "Bancomm bc635 TFP" /* who we are */
! 139: #define VMEHSREFID 0x7f7f1000 /* 127.127.16.00 refid hi strata */
! 140: /* clock type 16 is used here */
! 141: #define GMT 0 /* hour offset from Greenwich */
! 142:
! 143: /*
! 144: * Imported from ntp_timer module
! 145: */
! 146: extern u_long current_time; /* current time(s) */
! 147:
! 148: /*
! 149: * Imported from ntpd module
! 150: */
! 151: extern volatile int debug; /* global debug flag */
! 152:
! 153: /*
! 154: * VME unit control structure.
! 155: * Changes made to vmeunit structure. Most members are now available in the
! 156: * new refclockproc structure in ntp_refclock.h - 07/99 - Ganesh Ramasivan
! 157: */
! 158: struct vmeunit {
! 159: struct vmedate vmedata; /* data returned from vme read */
! 160: u_long lasttime; /* last time clock heard from */
! 161: };
! 162:
! 163: /*
! 164: * Function prototypes
! 165: */
! 166: static int vme_start (int, struct peer *);
! 167: static void vme_shutdown (int, struct peer *);
! 168: static void vme_receive (struct recvbuf *);
! 169: static void vme_poll (int unit, struct peer *);
! 170: struct vmedate *get_datumtime(struct vmedate *);
! 171: void tvme_fill(struct vmedate *, uint32_t btm[2]);
! 172: void stfp_time2tvme(struct vmedate *time_vme, struct stfp_time *stfp);
! 173: inline const char *DEVICE_NAME(int n);
! 174:
! 175:
! 176: /*
! 177: * Define the bc*() functions as weak so we can compile/link without them.
! 178: * Only clients with the card will have the proprietary vendor device driver
! 179: * and interface library needed for use on Linux/Windows platforms.
! 180: */
! 181: extern uint32_t __attribute__ ((weak)) bcReadBinTime(SYMMT_PCI_HANDLE, uint32_t *, uint32_t*, uint8_t*);
! 182: extern SYMMT_PCI_HANDLE __attribute__ ((weak)) bcStartPci(void);
! 183: extern void __attribute__ ((weak)) bcStopPci(SYMMT_PCI_HANDLE);
! 184:
! 185: /*
! 186: * Transfer vector
! 187: */
! 188: struct refclock refclock_bancomm = {
! 189: vme_start, /* start up driver */
! 190: vme_shutdown, /* shut down driver */
! 191: vme_poll, /* transmit poll message */
! 192: noentry, /* not used (old vme_control) */
! 193: noentry, /* initialize driver */
! 194: noentry, /* not used (old vme_buginfo) */
! 195: NOFLAGS /* not used */
! 196: };
! 197:
! 198: int fd_vme; /* file descriptor for ioctls */
! 199: int regvalue;
! 200: int tfp_type; /* mode selector, indicate platform and driver interface */
! 201: SYMMT_PCI_HANDLE stfp_handle;
! 202:
! 203: /**
! 204: * this macro returns the device name based on
! 205: * the platform we are running on and the device number
! 206: */
! 207: #if defined(__sun__)
! 208: inline const char *DEVICE_NAME(int n) {static char s[20]={0}; snprintf(s,19,"/dev/stfp%d",n);return s;}
! 209: #else
! 210: inline const char* DEVICE_NAME(int n) {static char s[20]={0}; snprintf(s,19,"/dev/btfp%d",n);return s;}
! 211: #endif /**__sun__**/
! 212:
! 213: /*
! 214: * vme_start - open the VME device and initialize data for processing
! 215: */
! 216: static int
! 217: vme_start(
! 218: int unit,
! 219: struct peer *peer
! 220: )
! 221: {
! 222: register struct vmeunit *vme;
! 223: struct refclockproc *pp;
! 224: int dummy;
! 225: char vmedev[20];
! 226:
! 227: tfp_type = (int)(peer->ttl);
! 228: switch (tfp_type) {
! 229: case 1:
! 230: case 3:
! 231: break;
! 232: case 2:
! 233: stfp_handle = bcStartPci(); /* init the card in lin/win */
! 234: break;
! 235: default:
! 236: break;
! 237: }
! 238: /*
! 239: * Open VME device
! 240: */
! 241: #ifdef DEBUG
! 242:
! 243: printf("Opening DATUM DEVICE %s\n",DEVICE_NAME(peer->refclkunit));
! 244: #endif
! 245: if ( (fd_vme = open(DEVICE_NAME(peer->refclkunit), O_RDWR)) < 0) {
! 246: msyslog(LOG_ERR, "vme_start: failed open of %s: %m", vmedev);
! 247: return (0);
! 248: }
! 249: else {
! 250: switch (tfp_type) {
! 251: case 1: break;
! 252: case 2: break;
! 253: case 3:break;
! 254: default:
! 255: /* Release capture lockout in case it was set before. */
! 256: if( ioctl( fd_vme, RUNLOCK, &dummy ) )
! 257: msyslog(LOG_ERR, "vme_start: RUNLOCK failed %m");
! 258:
! 259: regvalue = 0; /* More esoteric stuff to do... */
! 260: if( ioctl( fd_vme, WCR0, ®value ) )
! 261: msyslog(LOG_ERR, "vme_start: WCR0 failed %m");
! 262: break;
! 263: }
! 264: }
! 265:
! 266: /*
! 267: * Allocate unit structure
! 268: */
! 269: vme = (struct vmeunit *)emalloc(sizeof(struct vmeunit));
! 270: bzero((char *)vme, sizeof(struct vmeunit));
! 271:
! 272:
! 273: /*
! 274: * Set up the structures
! 275: */
! 276: pp = peer->procptr;
! 277: pp->unitptr = (caddr_t) vme;
! 278: pp->timestarted = current_time;
! 279:
! 280: pp->io.clock_recv = vme_receive;
! 281: pp->io.srcclock = (caddr_t)peer;
! 282: pp->io.datalen = 0;
! 283: pp->io.fd = fd_vme;
! 284:
! 285: /*
! 286: * All done. Initialize a few random peer variables, then
! 287: * return success. Note that root delay and root dispersion are
! 288: * always zero for this clock.
! 289: */
! 290: peer->precision = VMEPRECISION;
! 291: memcpy(&pp->refid, USNOREFID,4);
! 292: return (1);
! 293: }
! 294:
! 295:
! 296: /*
! 297: * vme_shutdown - shut down a VME clock
! 298: */
! 299: static void
! 300: vme_shutdown(
! 301: int unit,
! 302: struct peer *peer
! 303: )
! 304: {
! 305: register struct vmeunit *vme;
! 306: struct refclockproc *pp;
! 307:
! 308: /*
! 309: * Tell the I/O module to turn us off. We're history.
! 310: */
! 311: pp = peer->procptr;
! 312: vme = (struct vmeunit *)pp->unitptr;
! 313: io_closeclock(&pp->io);
! 314: pp->unitptr = NULL;
! 315: if (NULL != vme)
! 316: free(vme);
! 317: if (tfp_type == 2)
! 318: bcStopPci(stfp_handle);
! 319: }
! 320:
! 321:
! 322: /*
! 323: * vme_receive - receive data from the VME device.
! 324: *
! 325: * Note: This interface would be interrupt-driven. We don't use that
! 326: * now, but include a dummy routine for possible future adventures.
! 327: */
! 328: static void
! 329: vme_receive(
! 330: struct recvbuf *rbufp
! 331: )
! 332: {
! 333: }
! 334:
! 335:
! 336: /*
! 337: * vme_poll - called by the transmit procedure
! 338: */
! 339: static void
! 340: vme_poll(
! 341: int unit,
! 342: struct peer *peer
! 343: )
! 344: {
! 345: struct vmedate *tptr;
! 346: struct vmeunit *vme;
! 347: struct refclockproc *pp;
! 348: time_t tloc;
! 349: struct tm *tadr;
! 350:
! 351: pp = peer->procptr;
! 352: vme = (struct vmeunit *)pp->unitptr; /* Here is the structure */
! 353:
! 354: tptr = &vme->vmedata;
! 355: if ((tptr = get_datumtime(tptr)) == NULL ) {
! 356: refclock_report(peer, CEVNT_BADREPLY);
! 357: return;
! 358: }
! 359:
! 360: get_systime(&pp->lastrec);
! 361: pp->polls++;
! 362: vme->lasttime = current_time;
! 363:
! 364: /*
! 365: * Get VME time and convert to timestamp format.
! 366: * The year must come from the system clock.
! 367: */
! 368:
! 369: time(&tloc);
! 370: tadr = gmtime(&tloc);
! 371: tptr->year = (unsigned short)(tadr->tm_year + 1900);
! 372:
! 373: snprintf(pp->a_lastcode,
! 374: sizeof(pp->a_lastcode),
! 375: "%3.3d %2.2d:%2.2d:%2.2d.%.6ld %1d",
! 376: tptr->day,
! 377: tptr->hr,
! 378: tptr->mn,
! 379: tptr->sec,
! 380: tptr->frac,
! 381: tptr->status);
! 382:
! 383: pp->lencode = (u_short) strlen(pp->a_lastcode);
! 384:
! 385: pp->day = tptr->day;
! 386: pp->hour = tptr->hr;
! 387: pp->minute = tptr->mn;
! 388: pp->second = tptr->sec;
! 389: pp->nsec = tptr->frac;
! 390:
! 391: #ifdef DEBUG
! 392: if (debug)
! 393: printf("pp: %3d %02d:%02d:%02d.%06ld %1x\n",
! 394: pp->day, pp->hour, pp->minute, pp->second,
! 395: pp->nsec, tptr->status);
! 396: #endif
! 397: if (tptr->status ) { /* Status 0 is locked to ref., 1 is not */
! 398: refclock_report(peer, CEVNT_BADREPLY);
! 399: return;
! 400: }
! 401:
! 402: /*
! 403: * Now, compute the reference time value. Use the heavy
! 404: * machinery for the seconds and the millisecond field for the
! 405: * fraction when present. If an error in conversion to internal
! 406: * format is found, the program declares bad data and exits.
! 407: * Note that this code does not yet know how to do the years and
! 408: * relies on the clock-calendar chip for sanity.
! 409: */
! 410: if (!refclock_process(pp)) {
! 411: refclock_report(peer, CEVNT_BADTIME);
! 412: return;
! 413: }
! 414: pp->lastref = pp->lastrec;
! 415: refclock_receive(peer);
! 416: record_clock_stats(&peer->srcadr, pp->a_lastcode);
! 417: }
! 418:
! 419: struct vmedate *
! 420: get_datumtime(struct vmedate *time_vme)
! 421: {
! 422: char cbuf[7];
! 423: struct btfp_time vts;
! 424: uint32_t btm[2];
! 425: uint8_t dmy;
! 426: struct stfp_time stfpm;
! 427:
! 428: if (time_vme == NULL)
! 429: time_vme = emalloc(sizeof(*time_vme));
! 430:
! 431: switch (tfp_type) {
! 432: case 1: /* BSD, PCI, 2 32bit time words */
! 433: if (ioctl(fd_vme, READTIME, &btm)) {
! 434: msyslog(LOG_ERR, "get_bc63x error: %m");
! 435: return(NULL);
! 436: }
! 437: tvme_fill(time_vme, btm);
! 438: break;
! 439:
! 440: case 2: /* Linux/Windows, PCI, 2 32bit time words */
! 441: if (bcReadBinTime(stfp_handle, &btm[1], &btm[0], &dmy) == 0) {
! 442: msyslog(LOG_ERR, "get_datumtime error: %m");
! 443: return(NULL);
! 444: }
! 445: tvme_fill(time_vme, btm);
! 446: break;
! 447:
! 448: case 3: /** solaris **/
! 449: memset(&stfpm,0,sizeof(stfpm));
! 450:
! 451: /* we need the time in decimal format */
! 452: /* Here we rudely assume that we are the only user of the driver.
! 453: * Other programs will have to set their own time format before reading
! 454: * the time.
! 455: */
! 456: if(ioctl (fd_vme, SELTIMEFORMAT, TIME_DECIMAL)){
! 457: msyslog(LOG_ERR, "Could not set time format\n");
! 458: return (NULL);
! 459: }
! 460: /* read the time */
! 461: if (ioctl(fd_vme, READTIME, &stfpm)) {
! 462: msyslog(LOG_ERR, "ioctl error: %m");
! 463: return(NULL);
! 464: }
! 465: stfp_time2tvme(time_vme, &stfpm);
! 466: break;
! 467:
! 468: default: /* legacy bancomm card */
! 469:
! 470: if (ioctl(fd_vme, READTIME, &vts)) {
! 471: msyslog(LOG_ERR,
! 472: "get_datumtime error: %m");
! 473: return(NULL);
! 474: }
! 475: /* Get day */
! 476: snprintf(cbuf, sizeof(cbuf), "%3.3x",
! 477: ((vts.btfp_time[ 0 ] & 0x000f) << 8) +
! 478: ((vts.btfp_time[ 1 ] & 0xff00) >> 8));
! 479: time_vme->day = (unsigned short)atoi(cbuf);
! 480:
! 481: /* Get hour */
! 482: snprintf(cbuf, sizeof(cbuf), "%2.2x",
! 483: vts.btfp_time[ 1 ] & 0x00ff);
! 484: time_vme->hr = (unsigned short)atoi(cbuf);
! 485:
! 486: /* Get minutes */
! 487: snprintf(cbuf, sizeof(cbuf), "%2.2x",
! 488: (vts.btfp_time[ 2 ] & 0xff00) >> 8);
! 489: time_vme->mn = (unsigned short)atoi(cbuf);
! 490:
! 491: /* Get seconds */
! 492: snprintf(cbuf, sizeof(cbuf), "%2.2x",
! 493: vts.btfp_time[ 2 ] & 0x00ff);
! 494: time_vme->sec = (unsigned short)atoi(cbuf);
! 495:
! 496: /* Get microseconds. Yes, we ignore the 0.1 microsecond digit so
! 497: we can use the TVTOTSF function later on...*/
! 498:
! 499: snprintf(cbuf, sizeof(cbuf), "%4.4x%2.2x",
! 500: vts.btfp_time[ 3 ],
! 501: vts.btfp_time[ 4 ] >> 8);
! 502: time_vme->frac = (u_long) atoi(cbuf);
! 503:
! 504: /* Get status bit */
! 505: time_vme->status = (vts.btfp_time[0] & 0x0010) >> 4;
! 506:
! 507: break;
! 508: }
! 509:
! 510: if (time_vme->status)
! 511: return ((void *)NULL);
! 512: else
! 513: return (time_vme);
! 514: }
! 515: /* Assign values to time_vme struct. Mostly for readability */
! 516: void
! 517: tvme_fill(struct vmedate *time_vme, uint32_t btm[2])
! 518: {
! 519: struct tm maj;
! 520: uint32_t dmaj, dmin;
! 521:
! 522: dmaj = btm[1]; /* syntax sugar */
! 523: dmin = btm[0];
! 524:
! 525: gmtime_r(&dmaj, &maj);
! 526: time_vme->day = maj.tm_yday+1;
! 527: time_vme->hr = maj.tm_hour;
! 528: time_vme->mn = maj.tm_min;
! 529: time_vme->sec = maj.tm_sec;
! 530: time_vme->frac = (dmin & 0x000fffff) * 1000;
! 531: time_vme->frac += ((dmin & 0x00f00000) >> 20) * 100;
! 532: time_vme->status = (dmin & 0x01000000) >> 24;
! 533: return;
! 534: }
! 535:
! 536:
! 537: /* Assign values to time_vme struct. Mostly for readability */
! 538: void
! 539: stfp_time2tvme(struct vmedate *time_vme, struct stfp_time *stfp)
! 540: {
! 541:
! 542: time_vme->day = stfp->tm.tm_yday+1;
! 543: time_vme->hr = stfp->tm.tm_hour;
! 544: time_vme->mn = stfp->tm.tm_min;
! 545: time_vme->sec = stfp->tm.tm_sec;
! 546: time_vme->frac = stfp->usec*1000;
! 547: time_vme->frac += stfp->hnsec * 100;
! 548: time_vme->status = stfp->status;
! 549: return;
! 550: }
! 551: #else
! 552: int refclock_bancomm_bs;
! 553: #endif /* REFCLOCK */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to refclock_bancomm.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / ntpd