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 SCO Unix. *
25: * *
26: ***********************************************************************
27: * *
28: * A full PPSAPI interface to the SCO Unix 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: /*SCO UNIX version, TIOCDCDTIMESTAMP assumed to exist. */
50:
51: #ifndef _SYS_TIMEPPS_H_
52: #define _SYS_TIMEPPS_H_
53:
54: #include <termios.h> /* to get TIOCDCDTIMESTAMP */
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 Solaris)
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: struct timeval tv_save;
192: pps_seq_t serial;
193: } pps_unit_t;
194:
195: typedef pps_unit_t* pps_handle_t; /* pps handlebars */
196:
197: /*
198: *------ Here begins the implementation-specific part! ------
199: */
200:
201: #include <errno.h>
202:
203: /*
204: * create PPS handle from file descriptor
205: */
206:
207: static inline int
208: time_pps_create(
209: int filedes, /* file descriptor */
210: pps_handle_t *handle /* returned handle */
211: )
212: {
213: int one = 1;
214:
215: /*
216: * Check for valid arguments and attach PPS signal.
217: */
218:
219: if (!handle) {
220: errno = EFAULT;
221: return (-1); /* null pointer */
222: }
223:
224: /*
225: * Allocate and initialize default unit structure.
226: */
227:
228: *handle = malloc(sizeof(pps_unit_t));
229: if (!(*handle)) {
230: errno = EBADF;
231: return (-1); /* what, no memory? */
232: }
233:
234: memset(*handle, 0, sizeof(pps_unit_t));
235: (*handle)->filedes = filedes;
236: (*handle)->params.api_version = PPS_API_VERS_1;
237: (*handle)->params.mode = PPS_CAPTUREASSERT | PPS_TSFMT_TSPEC;
238: return (0);
239: }
240:
241: /*
242: * release PPS handle
243: */
244:
245: static inline int
246: time_pps_destroy(
247: pps_handle_t handle
248: )
249: {
250: /*
251: * Check for valid arguments and detach PPS signal.
252: */
253:
254: if (!handle) {
255: errno = EBADF;
256: return (-1); /* bad handle */
257: }
258: free(handle);
259: return (0);
260: }
261:
262: /*
263: * set parameters for handle
264: */
265:
266: static inline int
267: time_pps_setparams(
268: pps_handle_t handle,
269: const pps_params_t *params
270: )
271: {
272: int mode, mode_in;
273: /*
274: * Check for valid arguments and set parameters.
275: */
276:
277: if (!handle) {
278: errno = EBADF;
279: return (-1); /* bad handle */
280: }
281:
282: if (!params) {
283: errno = EFAULT;
284: return (-1); /* bad argument */
285: }
286:
287: /*
288: * There was no reasonable consensu in the API working group.
289: * I require `api_version' to be set!
290: */
291:
292: if (params->api_version != PPS_API_VERS_1) {
293: errno = EINVAL;
294: return(-1);
295: }
296:
297: /*
298: * only settable modes are PPS_CAPTUREASSERT and PPS_OFFSETASSERT
299: */
300:
301: mode_in = params->mode;
302:
303: /* turn off read-only bits */
304:
305: mode_in &= ~PPS_RO;
306:
307: /* test remaining bits, should only have captureassert and/or offsetassert */
308:
309: if (mode_in & ~(PPS_CAPTUREASSERT | PPS_OFFSETASSERT)) {
310: errno = EOPNOTSUPP;
311: return(-1);
312: }
313:
314: /*
315: * ok, ready to go.
316: */
317:
318: mode = handle->params.mode;
319: memcpy(&handle->params, params, sizeof(pps_params_t));
320: handle->params.api_version = PPS_API_VERS_1;
321: handle->params.mode = mode | mode_in;
322: return (0);
323: }
324:
325: /*
326: * get parameters for handle
327: */
328:
329: static inline int
330: time_pps_getparams(
331: pps_handle_t handle,
332: pps_params_t *params
333: )
334: {
335: /*
336: * Check for valid arguments and get parameters.
337: */
338:
339: if (!handle) {
340: errno = EBADF;
341: return (-1); /* bad handle */
342: }
343:
344: if (!params) {
345: errno = EFAULT;
346: return (-1); /* bad argument */
347: }
348:
349: memcpy(params, &handle->params, sizeof(pps_params_t));
350: return (0);
351: }
352:
353: /* (
354: * get capabilities for handle
355: */
356:
357: static inline int
358: time_pps_getcap(
359: pps_handle_t handle,
360: int *mode
361: )
362: {
363: /*
364: * Check for valid arguments and get capabilities.
365: */
366:
367: if (!handle) {
368: errno = EBADF;
369: return (-1); /* bad handle */
370: }
371:
372: if (!mode) {
373: errno = EFAULT;
374: return (-1); /* bad argument */
375: }
376: *mode = PPS_CAP;
377: return (0);
378: }
379:
380: /*
381: * Fetch timestamps
382: */
383:
384: static inline int
385: time_pps_fetch(
386: pps_handle_t handle,
387: const int tsformat,
388: pps_info_t *ppsinfo,
389: const struct timespec *timeout
390: )
391: {
392: struct timeval tv;
393: pps_info_t infobuf;
394:
395: /*
396: * Check for valid arguments and fetch timestamps
397: */
398:
399: if (!handle) {
400: errno = EBADF;
401: return (-1); /* bad handle */
402: }
403:
404: if (!ppsinfo) {
405: errno = EFAULT;
406: return (-1); /* bad argument */
407: }
408:
409: /*
410: * nb. PPS_CANWAIT is NOT set by the implementation, we can totally
411: * ignore the timeout variable.
412: */
413:
414: memset(&infobuf, 0, sizeof(infobuf));
415:
416: /*
417: * if not captureassert, nothing to return.
418: */
419:
420: if (!handle->params.mode & PPS_CAPTUREASSERT) {
421: memcpy(ppsinfo, &infobuf, sizeof(pps_info_t));
422: return (0);
423: }
424:
425: if (ioctl(instance->filedes, TIOCDCDTIMESTAMP, &tv) < 0) {
426: perror("time_pps_fetch:");
427: errno = EOPNOTSUPP;
428: return(-1);
429: }
430:
431: /*
432: * fake serial here
433: */
434:
435: if (tv.tv_sec != handle->tv_save.tv_sec || tv.tv_usec != handle->tv_save.tv_usec) {
436: handle->tv_save = tv;
437: handle->serial++;
438: }
439:
440: /*
441: * Apply offsets as specified. Note that only assert timestamps
442: * are captured by this interface.
443: */
444:
445: infobuf.assert_sequence = handle->serial;
446: infobuf.assert_timestamp.tv_sec = tv.tv_sec;
447: infobuf.assert_timestamp.tv_nsec = tv.tv_usec * 1000;
448:
449: if (handle->params.mode & PPS_OFFSETASSERT) {
450: infobuf.assert_timestamp.tv_sec += handle->params.assert_offset.tv_sec;
451: infobuf.assert_timestamp.tv_nsec += handle->params.assert_offset.tv_nsec;
452: PPS_NORMALIZE(infobuf.assert_timestamp);
453: }
454:
455: /*
456: * Translate to specified format
457: */
458:
459: switch (tsformat) {
460: case PPS_TSFMT_TSPEC:
461: break; /* timespec format requires no translation */
462:
463: case PPS_TSFMT_NTPFP: /* NTP format requires conversion to fraction form */
464: PPS_TSPECTONTP(infobuf.assert_timestamp_ntpfp);
465: break;
466:
467: default:
468: errno = EINVAL;
469: return (-1);
470: }
471:
472: infobuf.current_mode = handle->params.mode;
473: memcpy(ppsinfo, &infobuf, sizeof(pps_info_t));
474: return (0);
475: }
476:
477: /*
478: * specify kernel consumer
479: */
480:
481: static inline int
482: time_pps_kcbind(
483: pps_handle_t handle,
484: const int kernel_consumer,
485: const int edge, const int tsformat
486: )
487: {
488: /*
489: * Check for valid arguments and bind kernel consumer
490: */
491: if (!handle) {
492: errno = EBADF;
493: return (-1); /* bad handle */
494: }
495: if (geteuid() != 0) {
496: errno = EPERM;
497: return (-1); /* must be superuser */
498: }
499: errno = EOPNOTSUPP;
500: return(-1);
501: }
502:
503: #endif /* _SYS_TIMEPPS_H_ */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to timepps-SCO.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