Annotation of embedaddon/ntp/include/timepps-SunOS.h, revision 1.1
1.1 ! misho 1: /***********************************************************************
! 2: * *
! 3: * Copyright (c) David L. Mills 1999-2000 *
! 4: * *
! 5: * Permission to use, copy, modify, and distribute this software and *
! 6: * its documentation for any purpose and without fee is hereby *
! 7: * granted, provided that the above copyright notice appears in all *
! 8: * copies and that both the copyright notice and this permission *
! 9: * notice appear in supporting documentation, and that the name *
! 10: * University of Delaware not be used in advertising or publicity *
! 11: * pertaining to distribution of the software without specific, *
! 12: * written prior permission. The University of Delaware makes no *
! 13: * representations about the suitability this software for any *
! 14: * purpose. It is provided "as is" without express or implied *
! 15: * warranty. *
! 16: * *
! 17: ***********************************************************************
! 18: * *
! 19: * This header file complies with "Pulse-Per-Second API for UNIX-like *
! 20: * Operating Systems, Version 1.0", rfc2783. Credit is due Jeff Mogul *
! 21: * and Marc Brett, from whom much of this code was shamelessly stolen. *
! 22: * *
! 23: * this modified timepps.h can be used to provide a PPSAPI interface *
! 24: * to a machine running SunOS. *
! 25: * *
! 26: ***********************************************************************
! 27: * *
! 28: * A full PPSAPI interface to the SunOS kernel would be better, but *
! 29: * this at least removes the necessity for special coding from the NTP *
! 30: * NTP drivers. *
! 31: * *
! 32: ***********************************************************************
! 33: * *
! 34: * Some of this include file *
! 35: * Copyright (c) 1999 by Ulrich Windl, *
! 36: * based on code by Reg Clemens <reg@dwf.com> *
! 37: * based on code by Poul-Henning Kamp <phk@FreeBSD.org> *
! 38: * *
! 39: ***********************************************************************
! 40: * *
! 41: * "THE BEER-WARE LICENSE" (Revision 42): *
! 42: * <phk@FreeBSD.org> wrote this file. As long as you retain this *
! 43: * notice you can do whatever you want with this stuff. If we meet some*
! 44: * day, and you think this stuff is worth it, you can buy me a beer *
! 45: * in return. Poul-Henning Kamp *
! 46: * *
! 47: **********************************************************************/
! 48:
! 49: /* SunOS version, CIOGETEV assumed to exist for SunOS */
! 50:
! 51: #ifndef _SYS_TIMEPPS_H_
! 52: #define _SYS_TIMEPPS_H_
! 53:
! 54: #include <termios.h> /* to get CIOGETEV */
! 55:
! 56: /* Implementation note: the logical states ``assert'' and ``clear''
! 57: * are implemented in terms of the UART register, i.e. ``assert''
! 58: * means the bit is set.
! 59: */
! 60:
! 61: /*
! 62: * The following definitions are architecture independent
! 63: */
! 64:
! 65: #define PPS_API_VERS_1 1 /* API version number */
! 66: #define PPS_JAN_1970 2208988800UL /* 1970 - 1900 in seconds */
! 67: #define PPS_NANOSECOND 1000000000L /* one nanosecond in decimal */
! 68: #define PPS_FRAC 4294967296. /* 2^32 as a double */
! 69:
! 70: #define PPS_NORMALIZE(x) /* normalize timespec */ \
! 71: do { \
! 72: if ((x).tv_nsec >= PPS_NANOSECOND) { \
! 73: (x).tv_nsec -= PPS_NANOSECOND; \
! 74: (x).tv_sec++; \
! 75: } else if ((x).tv_nsec < 0) { \
! 76: (x).tv_nsec += PPS_NANOSECOND; \
! 77: (x).tv_sec--; \
! 78: } \
! 79: } while (0)
! 80:
! 81: #define PPS_TSPECTONTP(x) /* convert timespec to l_fp */ \
! 82: do { \
! 83: double d_temp; \
! 84: \
! 85: (x).integral += (unsigned int)PPS_JAN_1970; \
! 86: d_temp = (x).fractional * PPS_FRAC / PPS_NANOSECOND; \
! 87: if (d_temp >= PPS_FRAC) \
! 88: (x).integral++; \
! 89: (x).fractional = (unsigned int)d_temp; \
! 90: } while (0)
! 91:
! 92: /*
! 93: * Device/implementation parameters (mode)
! 94: */
! 95:
! 96: #define PPS_CAPTUREASSERT 0x01 /* capture assert events */
! 97: #define PPS_CAPTURECLEAR 0x02 /* capture clear events */
! 98: #define PPS_CAPTUREBOTH 0x03 /* capture assert and clear events */
! 99:
! 100: #define PPS_OFFSETASSERT 0x10 /* apply compensation for assert ev. */
! 101: #define PPS_OFFSETCLEAR 0x20 /* apply compensation for clear ev. */
! 102: #define PPS_OFFSETBOTH 0x30 /* apply compensation for both */
! 103:
! 104: #define PPS_CANWAIT 0x100 /* Can we wait for an event? */
! 105: #define PPS_CANPOLL 0x200 /* "This bit is reserved for */
! 106:
! 107: /*
! 108: * Kernel actions (mode)
! 109: */
! 110:
! 111: #define PPS_ECHOASSERT 0x40 /* feed back assert event to output */
! 112: #define PPS_ECHOCLEAR 0x80 /* feed back clear event to output */
! 113:
! 114: /*
! 115: * Timestamp formats (tsformat)
! 116: */
! 117:
! 118: #define PPS_TSFMT_TSPEC 0x1000 /* select timespec format */
! 119: #define PPS_TSFMT_NTPFP 0x2000 /* select NTP format */
! 120:
! 121: /*
! 122: * Kernel discipline actions (not used in SunOS)
! 123: */
! 124:
! 125: #define PPS_KC_HARDPPS 0 /* enable kernel consumer */
! 126: #define PPS_KC_HARDPPS_PLL 1 /* phase-lock mode */
! 127: #define PPS_KC_HARDPPS_FLL 2 /* frequency-lock mode */
! 128:
! 129: /*
! 130: * Type definitions
! 131: */
! 132:
! 133: typedef unsigned long pps_seq_t; /* sequence number */
! 134:
! 135: typedef struct ntp_fp {
! 136: unsigned int integral;
! 137: unsigned int fractional;
! 138: } ntp_fp_t; /* NTP-compatible time stamp */
! 139:
! 140: typedef union pps_timeu { /* timestamp format */
! 141: struct timespec tspec;
! 142: ntp_fp_t ntpfp;
! 143: unsigned long longpad[3];
! 144: } pps_timeu_t; /* generic data type to represent time stamps */
! 145:
! 146: /*
! 147: * Timestamp information structure
! 148: */
! 149:
! 150: typedef struct pps_info {
! 151: pps_seq_t assert_sequence; /* seq. num. of assert event */
! 152: pps_seq_t clear_sequence; /* seq. num. of clear event */
! 153: pps_timeu_t assert_tu; /* time of assert event */
! 154: pps_timeu_t clear_tu; /* time of clear event */
! 155: int current_mode; /* current mode bits */
! 156: } pps_info_t;
! 157:
! 158: #define assert_timestamp assert_tu.tspec
! 159: #define clear_timestamp clear_tu.tspec
! 160:
! 161: #define assert_timestamp_ntpfp assert_tu.ntpfp
! 162: #define clear_timestamp_ntpfp clear_tu.ntpfp
! 163:
! 164: /*
! 165: * Parameter structure
! 166: */
! 167:
! 168: typedef struct pps_params {
! 169: int api_version; /* API version # */
! 170: int mode; /* mode bits */
! 171: pps_timeu_t assert_off_tu; /* offset compensation for assert */
! 172: pps_timeu_t clear_off_tu; /* offset compensation for clear */
! 173: } pps_params_t;
! 174:
! 175: #define assert_offset assert_off_tu.tspec
! 176: #define clear_offset clear_off_tu.tspec
! 177:
! 178: #define assert_offset_ntpfp assert_off_tu.ntpfp
! 179: #define clear_offset_ntpfp clear_off_tu.ntpfp
! 180:
! 181: /*
! 182: * The following definitions are architecture-dependent
! 183: */
! 184:
! 185: #define PPS_CAP (PPS_CAPTUREASSERT | PPS_OFFSETASSERT | PPS_TSFMT_TSPEC | PPS_TSFMT_NTPFP)
! 186: #define PPS_RO (PPS_CANWAIT | PPS_CANPOLL | PPS_TSFMT_TSPEC | PPS_TSFMT_NTPFP)
! 187:
! 188: typedef struct {
! 189: int filedes; /* file descriptor */
! 190: pps_params_t params; /* PPS parameters set by user */
! 191: } pps_unit_t;
! 192:
! 193: typedef pps_unit_t* pps_handle_t; /* pps handlebars */
! 194:
! 195: /*
! 196: *------ Here begins the implementation-specific part! ------
! 197: */
! 198:
! 199: #include <errno.h>
! 200:
! 201: /*
! 202: * create PPS handle from file descriptor
! 203: */
! 204:
! 205: static inline int
! 206: time_pps_create(
! 207: int filedes, /* file descriptor */
! 208: pps_handle_t *handle /* returned handle */
! 209: )
! 210: {
! 211: /*
! 212: * Check for valid arguments and attach PPS signal.
! 213: */
! 214:
! 215: if (!handle) {
! 216: errno = EFAULT;
! 217: return (-1); /* null pointer */
! 218: }
! 219:
! 220: if (ioctl(filedes, I_PUSH, "ppsclock") < 0) {
! 221: perror("time_pps_create: I_PUSH ppsclock failed");
! 222: return (-1);
! 223: }
! 224:
! 225: /*
! 226: * Allocate and initialize default unit structure.
! 227: */
! 228:
! 229: *handle = malloc(sizeof(pps_unit_t));
! 230: if (!(*handle)) {
! 231: errno = EBADF;
! 232: return (-1); /* what, no memory? */
! 233: }
! 234:
! 235: memset(*handle, 0, sizeof(pps_unit_t));
! 236: (*handle)->filedes = filedes;
! 237: (*handle)->params.api_version = PPS_API_VERS_1;
! 238: (*handle)->params.mode = PPS_CAPTUREASSERT | PPS_TSFMT_TSPEC;
! 239: return (0);
! 240: }
! 241:
! 242: /*
! 243: * release PPS handle
! 244: */
! 245:
! 246: static inline int
! 247: time_pps_destroy(
! 248: pps_handle_t handle
! 249: )
! 250: {
! 251: /*
! 252: * Check for valid arguments and detach PPS signal.
! 253: */
! 254:
! 255: if (!handle) {
! 256: errno = EBADF;
! 257: return (-1); /* bad handle */
! 258: }
! 259: free(handle);
! 260: return (0);
! 261: }
! 262:
! 263: /*
! 264: * set parameters for handle
! 265: */
! 266:
! 267: static inline int
! 268: time_pps_setparams(
! 269: pps_handle_t handle,
! 270: const pps_params_t *params
! 271: )
! 272: {
! 273: int mode, mode_in;
! 274: /*
! 275: * Check for valid arguments and set parameters.
! 276: */
! 277:
! 278: if (!handle) {
! 279: errno = EBADF;
! 280: return (-1); /* bad handle */
! 281: }
! 282:
! 283: if (!params) {
! 284: errno = EFAULT;
! 285: return (-1); /* bad argument */
! 286: }
! 287:
! 288: /*
! 289: * There was no reasonable consensu in the API working group.
! 290: * I require `api_version' to be set!
! 291: */
! 292:
! 293: if (params->api_version != PPS_API_VERS_1) {
! 294: errno = EINVAL;
! 295: return(-1);
! 296: }
! 297:
! 298: /*
! 299: * only settable modes are PPS_CAPTUREASSERT and PPS_OFFSETASSERT
! 300: */
! 301:
! 302: mode_in = params->mode;
! 303:
! 304: /* turn off read-only bits */
! 305:
! 306: mode_in &= ~PPS_RO;
! 307:
! 308: /* test remaining bits, should only have captureassert and/or offsetassert */
! 309:
! 310: if (mode_in & ~(PPS_CAPTUREASSERT | PPS_OFFSETASSERT)) {
! 311: errno = EOPNOTSUPP;
! 312: return(-1);
! 313: }
! 314:
! 315: /*
! 316: * ok, ready to go.
! 317: */
! 318:
! 319: mode = handle->params.mode;
! 320: memcpy(&handle->params, params, sizeof(pps_params_t));
! 321: handle->params.api_version = PPS_API_VERS_1;
! 322: handle->params.mode = mode | mode_in;
! 323: return (0);
! 324: }
! 325:
! 326: /*
! 327: * get parameters for handle
! 328: */
! 329:
! 330: static inline int
! 331: time_pps_getparams(
! 332: pps_handle_t handle,
! 333: pps_params_t *params
! 334: )
! 335: {
! 336: /*
! 337: * Check for valid arguments and get parameters.
! 338: */
! 339:
! 340: if (!handle) {
! 341: errno = EBADF;
! 342: return (-1); /* bad handle */
! 343: }
! 344:
! 345: if (!params) {
! 346: errno = EFAULT;
! 347: return (-1); /* bad argument */
! 348: }
! 349:
! 350: memcpy(params, &handle->params, sizeof(pps_params_t));
! 351: return (0);
! 352: }
! 353:
! 354: /* (
! 355: * get capabilities for handle
! 356: */
! 357:
! 358: static inline int
! 359: time_pps_getcap(
! 360: pps_handle_t handle,
! 361: int *mode
! 362: )
! 363: {
! 364: /*
! 365: * Check for valid arguments and get capabilities.
! 366: */
! 367:
! 368: if (!handle) {
! 369: errno = EBADF;
! 370: return (-1); /* bad handle */
! 371: }
! 372:
! 373: if (!mode) {
! 374: errno = EFAULT;
! 375: return (-1); /* bad argument */
! 376: }
! 377: *mode = PPS_CAP;
! 378: return (0);
! 379: }
! 380:
! 381: /*
! 382: * Fetch timestamps
! 383: */
! 384:
! 385: static inline int
! 386: time_pps_fetch(
! 387: pps_handle_t handle,
! 388: const int tsformat,
! 389: pps_info_t *ppsinfo,
! 390: const struct timespec *timeout
! 391: )
! 392: {
! 393: struct ppsclockev {
! 394: struct timeval tv;
! 395: u_int serial;
! 396: } ev;
! 397: pps_info_t infobuf;
! 398:
! 399: /*
! 400: * Check for valid arguments and fetch timestamps
! 401: */
! 402:
! 403: if (!handle) {
! 404: errno = EBADF;
! 405: return (-1); /* bad handle */
! 406: }
! 407:
! 408: if (!ppsinfo) {
! 409: errno = EFAULT;
! 410: return (-1); /* bad argument */
! 411: }
! 412:
! 413: /*
! 414: * nb. PPS_CANWAIT is NOT set by the implementation, we can totally
! 415: * ignore the timeout variable.
! 416: */
! 417:
! 418: memset(&infobuf, 0, sizeof(infobuf));
! 419:
! 420: /*
! 421: * if not captureassert, nothing to return.
! 422: */
! 423:
! 424: if (!handle->params.mode & PPS_CAPTUREASSERT) {
! 425: memcpy(ppsinfo, &infobuf, sizeof(pps_info_t));
! 426: return (0);
! 427: }
! 428:
! 429: #if defined(__STDC__)
! 430: #define CIOGETEV _IOR('C', 0, struct ppsclockev) /* get last pps event */
! 431: #else
! 432: #define CIOGETEV _IOR(C, 0, struct ppsclockev) /* get last pps event */
! 433: #endif
! 434:
! 435: if (ioctl(handle->filedes, CIOGETEV, (caddr_t) &ev) < 0) {
! 436: perror("time_pps_fetch:");
! 437: errno = EOPNOTSUPP;
! 438: return(-1);
! 439: }
! 440:
! 441: /*
! 442: * Apply offsets as specified. Note that only assert timestamps
! 443: * are captured by this interface.
! 444: */
! 445:
! 446: infobuf.assert_sequence = ev.serial;
! 447: infobuf.assert_timestamp.tv_sec = ev.tv.tv_sec;
! 448: infobuf.assert_timestamp.tv_nsec = ev.tv.tv_usec * 1000;
! 449:
! 450: if (handle->params.mode & PPS_OFFSETASSERT) {
! 451: infobuf.assert_timestamp.tv_sec += handle->params.assert_offset.tv_sec;
! 452: infobuf.assert_timestamp.tv_nsec += handle->params.assert_offset.tv_nsec;
! 453: PPS_NORMALIZE(infobuf.assert_timestamp);
! 454: }
! 455:
! 456: /*
! 457: * Translate to specified format
! 458: */
! 459:
! 460: switch (tsformat) {
! 461: case PPS_TSFMT_TSPEC:
! 462: break; /* timespec format requires no translation */
! 463:
! 464: case PPS_TSFMT_NTPFP: /* NTP format requires conversion to fraction form */
! 465: PPS_TSPECTONTP(infobuf.assert_timestamp_ntpfp);
! 466: break;
! 467:
! 468: default:
! 469: errno = EINVAL;
! 470: return (-1);
! 471: }
! 472:
! 473: infobuf.current_mode = handle->params.mode;
! 474: memcpy(ppsinfo, &infobuf, sizeof(pps_info_t));
! 475: return (0);
! 476: }
! 477:
! 478: /*
! 479: * specify kernel consumer
! 480: */
! 481:
! 482: static inline int
! 483: time_pps_kcbind(
! 484: pps_handle_t handle,
! 485: const int kernel_consumer,
! 486: const int edge, const int tsformat
! 487: )
! 488: {
! 489: /*
! 490: * Check for valid arguments and bind kernel consumer
! 491: */
! 492: if (!handle) {
! 493: errno = EBADF;
! 494: return (-1); /* bad handle */
! 495: }
! 496: if (geteuid() != 0) {
! 497: errno = EPERM;
! 498: return (-1); /* must be superuser */
! 499: }
! 500: errno = EOPNOTSUPP;
! 501: return(-1);
! 502: }
! 503:
! 504: #endif /* _SYS_TIMEPPS_H_ */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to timepps-SunOS.h CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / include