xref: /freebsd/contrib/ntp/include/timepps-SCO.h (revision 8d20be1e22095c27faf8fe8b2f0d089739cc742e) 
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_ */
504