![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to timepps.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 / ports / winnt / include|
Return to timepps.h CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / ports / winnt / include |
1.1 misho 1: /***********************************************************************
2: * *
3: * Copyright (c) David L. Mills 1999-2009 *
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 Windows with one or more backend provider DLLs *
25: * implementing the provider interfaces defined herein. *
26: * *
27: * This Windows version was derived by Dave Hart *
28: * <davehart@davehart.com> from Mills' timepps-Solaris.h *
29: * *
30: ***********************************************************************
31: * *
32: * Some of this include file *
33: * Copyright (c) 1999 by Ulrich Windl, *
34: * based on code by Reg Clemens <reg@dwf.com> *
35: * based on code by Poul-Henning Kamp <phk@FreeBSD.org> *
36: * *
37: ***********************************************************************
38: * *
39: * "THE BEER-WARE LICENSE" (Revision 42): *
40: * <phk@FreeBSD.org> wrote this file. As long as you retain this *
41: * notice you can do whatever you want with this stuff. If we meet some*
42: * day, and you think this stuff is worth it, you can buy me a beer *
43: * in return. Poul-Henning Kamp *
44: * *
45: **********************************************************************/
46:
47: #ifndef TIMEPPS_H
48: #define TIMEPPS_H
49:
50: #include "sys/time.h" /* in ntp ref source declares struct timespec */
51:
52: /*
53: * The following definitions are architecture independent
54: */
55:
56: #define PPS_API_VERS_1 1 /* API version number */
57: #define PPS_JAN_1970 2208988800UL /* 1970 - 1900 in seconds */
58: #define PPS_NANOSECOND 1000000000L /* one nanosecond in decimal */
59: #define PPS_FRAC 4294967296. /* 2^32 as a double */
60: #define PPS_HECTONANOSECONDS 10000000 /* 100ns units in a second */
61: #define PPS_FILETIME_1970 0x019db1ded53e8000 /* unix epoch to Windows */
62:
63: #define PPS_NORMALIZE(x) /* normalize timespec */ \
64: do { \
65: if ((x).tv_nsec >= PPS_NANOSECOND) { \
66: (x).tv_nsec -= PPS_NANOSECOND; \
67: (x).tv_sec++; \
68: } else if ((x).tv_nsec < 0) { \
69: (x).tv_nsec += PPS_NANOSECOND; \
70: (x).tv_sec--; \
71: } \
72: } while (0)
73:
74: #define PPS_TSPECTONTP(x) /* convert timespec to ntp_fp */ \
75: do { \
76: double d_frac; \
77: \
78: d_frac = ((struct timespec)&(x))->tv_nsec \
79: * PPS_FRAC / PPS_NANOSECOND; \
80: (x).integral = ((struct timespec)&(x))->tv_sec \
81: + PPS_JAN_1970; \
82: (x).fractional = (unsigned int)d_frac; \
83: if (d_frac >= PPS_FRAC) \
84: (x).integral++; \
85: } while (0)
86:
87: #define PPS_NTPTOTSPEC(x) /* convert ntp_fp to timespec */ \
88: do { \
89: double d_frac; \
90: \
91: /* careful, doing in place and tv_sec may be 64bit */ \
92: d_frac = (double)((ntp_fp_t *)&(x))->fractional \
93: * PPS_NANOSECOND / PPS_FRAC; \
94: (x).tv_sec = ((ntp_fp_t *)&(x))->integral \
95: - (time_t)PPS_JAN_1970; \
96: (x).tv_nsec = (long)d_frac; \
97: } while (0)
98:
99:
100: /*
101: * Device/implementation parameters (mode)
102: */
103:
104: #define PPS_CAPTUREASSERT 0x01 /* capture assert events */
105: #define PPS_CAPTURECLEAR 0x02 /* capture clear events */
106: #define PPS_CAPTUREBOTH 0x03 /* capture assert and clear events */
107:
108: #define PPS_OFFSETASSERT 0x10 /* apply compensation for assert ev. */
109: #define PPS_OFFSETCLEAR 0x20 /* apply compensation for clear ev. */
110: #define PPS_OFFSETBOTH 0x30 /* apply compensation for both */
111:
112: #define PPS_CANWAIT 0x100 /* Can we wait for an event? */
113: #define PPS_CANPOLL 0x200 /* "This bit is reserved for */
114:
115: /*
116: * Kernel actions (mode)
117: */
118:
119: #define PPS_ECHOASSERT 0x40 /* feed back assert event to output */
120: #define PPS_ECHOCLEAR 0x80 /* feed back clear event to output */
121:
122: /*
123: * Timestamp formats (tsformat)
124: */
125:
126: #define PPS_TSFMT_TSPEC 0x1000 /* select timespec format */
127: #define PPS_TSFMT_NTPFP 0x2000 /* select NTP format */
128: #define PPS_TSFMT_BOTH (PPS_TSFMT_TSPEC | PPS_TSFMT_NTPFP)
129:
130: /*
131: * Kernel discipline actions (not used in Windows yet)
132: */
133:
134: #define PPS_KC_HARDPPS 0 /* enable kernel consumer */
135: #define PPS_KC_HARDPPS_PLL 1 /* phase-lock mode */
136: #define PPS_KC_HARDPPS_FLL 2 /* frequency-lock mode */
137:
138: /*
139: * Type definitions
140: */
141:
142: typedef unsigned long pps_seq_t; /* sequence number */
143:
144: #pragma warning(push)
145: #pragma warning(disable: 201) /* nonstd extension nameless union */
146:
147: typedef struct ntp_fp {
148: union ntp_fp_sec {
149: unsigned int integral;
150: int s_integral;
151: };
152: unsigned int fractional;
153: } ntp_fp_t; /* NTP-compatible time stamp */
154:
155: #pragma warning(pop)
156:
157: typedef union pps_timeu { /* timestamp format */
158: struct timespec tspec;
159: ntp_fp_t ntpfp;
160: unsigned long longpad[3];
161: } pps_timeu_t; /* generic data type to represent time stamps */
162:
163: /* addition of NTP fixed-point format */
164:
165: #define NTPFP_M_ADD(r_i, r_f, a_i, a_f) /* r += a */ \
166: do { \
167: register u_int32 lo_tmp; \
168: register u_int32 hi_tmp; \
169: \
170: lo_tmp = ((r_f) & 0xffff) + ((a_f) & 0xffff); \
171: hi_tmp = (((r_f) >> 16) & 0xffff) + (((a_f) >> 16) & 0xffff); \
172: if (lo_tmp & 0x10000) \
173: hi_tmp++; \
174: (r_f) = ((hi_tmp & 0xffff) << 16) | (lo_tmp & 0xffff); \
175: \
176: (r_i) += (a_i); \
177: if (hi_tmp & 0x10000) \
178: (r_i)++; \
179: } while (0)
180:
181: #define NTPFP_L_ADDS(r, a) NTPFP_M_ADD((r)->integral, (r)->fractional, \
182: (a)->s_integral, (a)->fractional)
183:
184:
185: /*
186: * Timestamp information structure
187: */
188:
189: typedef struct pps_info {
190: pps_seq_t assert_sequence; /* seq. num. of assert event */
191: pps_seq_t clear_sequence; /* seq. num. of clear event */
192: pps_timeu_t assert_tu; /* time of assert event */
193: pps_timeu_t clear_tu; /* time of clear event */
194: int current_mode; /* current mode bits */
195: } pps_info_t;
196:
197: #define assert_timestamp assert_tu.tspec
198: #define clear_timestamp clear_tu.tspec
199:
200: #define assert_timestamp_ntpfp assert_tu.ntpfp
201: #define clear_timestamp_ntpfp clear_tu.ntpfp
202:
203: /*
204: * Parameter structure
205: */
206:
207: typedef struct pps_params {
208: int api_version; /* API version # */
209: int mode; /* mode bits */
210: pps_timeu_t assert_off_tu; /* offset compensation for assert */
211: pps_timeu_t clear_off_tu; /* offset compensation for clear */
212: } pps_params_t;
213:
214: #define assert_offset assert_off_tu.tspec
215: #define clear_offset clear_off_tu.tspec
216:
217: #define assert_offset_ntpfp assert_off_tu.ntpfp
218: #define clear_offset_ntpfp clear_off_tu.ntpfp
219:
220: /*
221: *------ Here begins the implementation-specific part! ------
222: */
223:
224: #include <windows.h>
225: #include <errno.h>
226: #include <stddef.h> /* offsetof() */
227: #include <io.h> /* _get_osfhandle() */
228:
229: #ifndef EOPNOTSUPP
230: #define EOPNOTSUPP 45
231: #endif
232:
233: typedef UINT_PTR pps_handle_t; /* pps handlebars */
234:
235: #ifndef inline
236: #define inline __inline
237: #endif
238:
239: /*
240: * ntpd on Windows is typically distributed as a binary as few users
241: * have the tools needed to build from source. Rather than build
242: * a single timepps.h for Windows which knows how to talk to all
243: * PPS implementations frozen in time as of compiling, this timepps.h
244: * allows one or more backend providers to be used by naming a DLL
245: * which exports the provider interfaces defined here.
246: */
247: typedef enum ppsapi_magic_tag {
248: PPSAPI_MAGIC_UNIT = 0x70707355, /* ppsU */
249: } ppsapi_magic;
250:
251: typedef struct {
252: struct pps_provider_tag *provider;
253: void * context;/* provider's unit pointer */
254: ppsapi_magic magic; /* to detect invalid handles */
255: pps_params_t params; /* PPS parameters set by user */
256: } pps_unit_t;
257:
258: typedef void (*ppps_ntp_timestamp_from_counter)(
259: ntp_fp_t *result,
260: ULONGLONG Timestamp,
261: ULONGLONG Counterstamp
262: );
263:
264: typedef pps_handle_t (*pcreate_pps_handle)(
265: void * prov_context
266: );
267:
268: /*
269: * ppsapi_prov_init() - exported by backend DLLs
270: *
271: * Return value is pps capabilities available to PPSAPI consumers
272: * via time_pps_getcaps().
273: */
274: #define PPSAPI_TIMEPPS_PROV_VER 2
275:
276: typedef int (WINAPI *pppsapi_prov_init)(
277: int ppsapi_timepps_prov_ver,
278: pcreate_pps_handle create_pps_handle,
279: ppps_ntp_timestamp_from_counter ntp_timestamp_from_counter,
280: char * short_name_buf,
281: size_t short_name_size,
282: char * full_name_buf,
283: size_t full_name_size
284: );
285:
286: typedef int (WINAPI *provtime_pps_create)(
287: HANDLE winhandle, /* user device handle */
288: pps_handle_t *phandle /* returned handle */
289: );
290:
291: typedef int (WINAPI *provtime_pps_destroy)(
292: pps_unit_t * unit,
293: void * context
294: );
295:
296: typedef int (WINAPI *provtime_pps_setparams)(
297: pps_unit_t * unit,
298: void * context,
299: const pps_params_t * params
300: );
301:
302: typedef int (WINAPI *provtime_pps_fetch)(
303: pps_unit_t * unit,
304: void * context,
305: const int tsformat,
306: pps_info_t * pinfo,
307: const struct timespec * timeout
308: );
309:
310: typedef int (WINAPI *provtime_pps_kcbind)(
311: pps_unit_t * unit,
312: void * context,
313: const int kernel_consumer,
314: const int edge,
315: const int tsformat
316: );
317:
318: typedef struct pps_provider_tag {
319: struct pps_provider_tag *next;
320: int caps;
321: char * short_name;
322: char * full_name;
323: provtime_pps_create ptime_pps_create;
324: provtime_pps_destroy ptime_pps_destroy;
325: provtime_pps_setparams ptime_pps_setparams;
326: provtime_pps_fetch ptime_pps_fetch;
327: provtime_pps_kcbind ptime_pps_kcbind;
328: } ppsapi_provider;
329:
330: static ppsapi_provider * g_provider_list;
331: static ppsapi_provider * g_curr_provider;
332:
333:
334: static inline pps_handle_t
335: internal_create_pps_handle(
336: void * prov_context
337: )
338: {
339: pps_unit_t * punit;
340:
341: if (NULL == g_curr_provider) {
342: fprintf(stderr, "create_pps_handle: provider backend called me outside time_pps_create\n");
343: punit = NULL;
344: } else
345: punit = malloc(sizeof(*punit));
346: if (punit != NULL) {
347: punit->provider = g_curr_provider;
348: punit->context = prov_context;
349: punit->magic = PPSAPI_MAGIC_UNIT;
350: memset(&punit->params, 0, sizeof(punit->params));
351: }
352: return (pps_handle_t)punit;
353: }
354:
355: static inline pps_unit_t *
356: unit_from_ppsapi_handle(
357: pps_handle_t handle
358: )
359: {
360: pps_unit_t *punit;
361:
362: punit = (pps_unit_t *)handle;
363: if (PPSAPI_MAGIC_UNIT != punit->magic)
364: punit = NULL;
365: return punit;
366: }
367:
368: /*
369: * ntpd on Windows only looks to errno after finding
370: * GetLastError returns NO_ERROR. To accomodate its
371: * use of msyslog in portable code such as refclock_atom.c,
372: * this implementation always clears the Windows
373: * error code using SetLastError(NO_ERROR) when
374: * returning an errno. This is also a good idea
375: * for any non-ntpd clients as they should rely only
376: * the errno for PPSAPI functions.
377: */
378: #define RETURN_PPS_ERRNO(e) \
379: do { \
380: SetLastError(NO_ERROR); \
381: errno = (e); \
382: return -1; \
383: } while (0)
384:
385:
386: #ifdef OWN_PPS_NTP_TIMESTAMP_FROM_COUNTER
387: extern void pps_ntp_timestamp_from_counter(ntp_fp_t *, ULONGLONG, ULONGLONG);
388: #else
389: /*
390: * helper routine for serialpps.sys ioctl which returns
391: * performance counter "timestamp" as well as a system
392: * FILETIME timestamp. Converts one of the inputs to
393: * NTP fixed-point format.
394: *
395: * You will probably want to supply your own and #define
396: * OWN_PPS_NTP_TIMESTAMP_FROM_COUNTER, as this stub
397: * converts only the low-resolution system timestamp.
398: *
399: * When implementing a provider, use the pointer to this
400: * conversion function supplied to your prov_init(), as
401: * the copy in your DLL will likely be the stub below,
402: * where you want the one provided by the PPSAPI client
403: * such as ntpd.
404: */
405: static inline void
406: pps_ntp_timestamp_from_counter(
407: ntp_fp_t *result,
408: ULONGLONG Timestamp,
409: ULONGLONG Counterstamp)
410: {
411: ULONGLONG BiasedTimestamp;
412:
413: /* convert from 100ns units to NTP fixed point format */
414:
415: BiasedTimestamp = Timestamp - PPS_FILETIME_1970;
416: result->integral = PPS_JAN_1970 +
417: (unsigned)(BiasedTimestamp / PPS_HECTONANOSECONDS);
418: result->fractional =
419: (unsigned) ((BiasedTimestamp % PPS_HECTONANOSECONDS) *
420: (PPS_FRAC / PPS_HECTONANOSECONDS));
421: }
422: #endif
423:
424:
425: static inline int
426: load_pps_provider(
427: char * dllpath
428: )
429: {
430: char short_name[16];
431: char full_name[64];
432: ppsapi_provider * prov;
433: HMODULE hmod;
434: pppsapi_prov_init pprov_init;
435:
436: prov = malloc(sizeof(*prov));
437: if (NULL == prov)
438: return ENOMEM;
439:
440: hmod = LoadLibrary(dllpath);
441: if (NULL == hmod) {
442: fprintf(stderr, "load_pps_provider: LoadLibrary(%s) error %u\n", dllpath, GetLastError());
443: free(prov);
444: return ENOENT;
445: }
446:
447: pprov_init = (pppsapi_prov_init)GetProcAddress(hmod, "ppsapi_prov_init");
448: if (NULL == pprov_init) {
449: fprintf(stderr, "load_pps_provider: entrypoint ppsapi_prov_init not found in %s\n", dllpath);
450: free(prov);
451: FreeLibrary(hmod);
452: return EFAULT;
453: }
454:
455: prov->caps = (*pprov_init)(PPSAPI_TIMEPPS_PROV_VER,
456: &internal_create_pps_handle,
457: &pps_ntp_timestamp_from_counter,
458: short_name, sizeof(short_name),
459: full_name, sizeof(full_name));
460:
461: if (!prov->caps) {
462: free(prov);
463: FreeLibrary(hmod);
464: return EACCES;
465: }
466:
467: prov->short_name = _strdup(short_name);
468: prov->full_name = _strdup(full_name);
469:
470: if (NULL == prov->short_name || !prov->short_name[0]
471: || NULL == prov->full_name || !prov->full_name[0]) {
472:
473: if (prov->short_name)
474: free(prov->short_name);
475: if (prov->full_name)
476: free(prov->full_name);
477: free(prov);
478: FreeLibrary(hmod);
479: return EINVAL;
480: }
481:
482: prov->ptime_pps_create = (provtime_pps_create)
483: GetProcAddress(hmod, "prov_time_pps_create");
484: prov->ptime_pps_destroy = (provtime_pps_destroy)
485: GetProcAddress(hmod, "prov_time_pps_destroy");
486: prov->ptime_pps_setparams = (provtime_pps_setparams)
487: GetProcAddress(hmod, "prov_time_pps_setparams");
488: prov->ptime_pps_fetch = (provtime_pps_fetch)
489: GetProcAddress(hmod, "prov_time_pps_fetch");
490: prov->ptime_pps_kcbind = (provtime_pps_kcbind)
491: GetProcAddress(hmod, "prov_time_pps_kcbind");
492:
493: if (NULL == prov->ptime_pps_create
494: || NULL == prov->ptime_pps_destroy
495: || NULL == prov->ptime_pps_setparams
496: || NULL == prov->ptime_pps_fetch
497: || NULL == prov->ptime_pps_kcbind) {
498:
499: fprintf(stderr, "PPSAPI provider %s missing entrypoint\n",
500: prov->short_name);
501: free(prov->short_name);
502: free(prov->full_name);
503: free(prov);
504: FreeLibrary(hmod);
505: return EINVAL;
506: }
507:
508: fprintf(stderr, "loaded PPSAPI provider %s caps 0x%x provider %p\n",
509: prov->full_name, prov->caps, prov);
510:
511: prov->next = g_provider_list;
512: g_provider_list = prov;
513:
514: return 0;
515: }
516:
517:
518: /*
519: * time_pps_create - create PPS handle from file descriptor
520: *
521: * This is the initial entrypoint of PPSAPI from the client. Note
522: * to maintain source compatibility with Unix, the input file
523: * descriptor really is a descriptor from the C runtime low-numbered
524: * descriptor namespace, though it may have been converted from a
525: * native Windows HANDLE using _open_osfhandle().
526: */
527: static inline int
528: time_pps_create(
529: int filedes,/* device file descriptor */
530: pps_handle_t * phandle /* returned handle */
531: )
532: {
533: HANDLE winhandle;
534: char * dlls;
535: char * dll;
536: char * pch;
537: ppsapi_provider * prov;
538: pps_handle_t ppshandle;
539: int err;
540:
541: if (NULL == phandle)
542: RETURN_PPS_ERRNO(EFAULT);
543:
544: winhandle = (HANDLE)_get_osfhandle(filedes);
545: fprintf(stderr, "time_pps_create(%d) got winhandle %p\n", filedes, winhandle);
546: if (INVALID_HANDLE_VALUE == winhandle)
547: RETURN_PPS_ERRNO(EBADF);
548:
549: /*
550: * For initial testing the list of PPSAPI backend
551: * providers is provided by the environment variable
552: * PPSAPI_DLLS, separated by semicolons such as
553: * PPSAPI_DLLS=c:\ntp\serial_ppsapi.dll;..\parport_ppsapi.dll
554: * There are a million better ways, such as a well-known
555: * registry key under which a value is created for each
556: * provider DLL installed, or even a platform-specific
557: * ntp.conf directive or command-line switch.
558: */
559: dlls = getenv("PPSAPI_DLLS");
560: if (dlls != NULL && NULL == g_provider_list) {
561: dlls = dll = _strdup(dlls);
562: fprintf(stderr, "getenv(PPSAPI_DLLS) gives %s\n", dlls);
563: } else
564: dlls = dll = NULL;
565:
566: while (dll != NULL && dll[0]) {
567: pch = strchr(dll, ';');
568: if (pch != NULL)
569: *pch = 0;
570: err = load_pps_provider(dll);
571: if (err) {
572: fprintf(stderr, "load_pps_provider(%s) got errno %d\n", dll, err);
573: RETURN_PPS_ERRNO(err);
574: }
575: dll = (NULL == pch)
576: ? NULL
577: : pch + 1;
578: }
579:
580: if (NULL != dlls)
581: free(dlls);
582: dlls = dll = NULL;
583:
584: /*
585: * Hand off to each provider in turn until one returns a PPS
586: * handle or they've all declined.
587: */
588: for (prov = g_provider_list; prov != NULL; prov = prov->next) {
589: ppshandle = 0;
590: g_curr_provider = prov;
591: err = (*prov->ptime_pps_create)(winhandle, &ppshandle);
592: g_curr_provider = NULL;
593: fprintf(stderr, "%s prov_time_pps_create(%p) returned %d\n",
594: prov->short_name, winhandle, err);
595: if (!err && ppshandle) {
596: *phandle = ppshandle;
597: return 0;
598: }
599: }
600:
601: fprintf(stderr, "PPSAPI provider list %p\n", g_provider_list);
602:
603: RETURN_PPS_ERRNO(ENOEXEC);
604: }
605:
606:
607: /*
608: * release PPS handle
609: */
610:
611: static inline int
612: time_pps_destroy(
613: pps_handle_t handle
614: )
615: {
616: pps_unit_t * punit;
617: int err;
618:
619: if (!handle)
620: RETURN_PPS_ERRNO(EBADF);
621:
622: punit = unit_from_ppsapi_handle(handle);
623:
624: if (NULL == punit)
625: RETURN_PPS_ERRNO(EBADF);
626:
627: err = (*punit->provider->ptime_pps_destroy)(punit, punit->context);
628:
629: free(punit);
630:
631: if (err)
632: RETURN_PPS_ERRNO(err);
633: else
634: return 0;
635: }
636:
637: /*
638: * set parameters for handle
639: */
640:
641: static inline int
642: time_pps_setparams(
643: pps_handle_t handle,
644: const pps_params_t *params
645: )
646: {
647: pps_unit_t * punit;
648: int err;
649:
650: /*
651: * Check for valid arguments and set parameters.
652: */
653: if (!handle)
654: RETURN_PPS_ERRNO(EBADF);
655:
656: punit = unit_from_ppsapi_handle(handle);
657:
658: if (NULL == punit)
659: RETURN_PPS_ERRNO(EBADF);
660:
661: if (NULL == params)
662: RETURN_PPS_ERRNO(EFAULT);
663:
664: err = (*punit->provider->ptime_pps_setparams)(punit, punit->context, params);
665:
666: if (err)
667: RETURN_PPS_ERRNO(err);
668: else
669: return 0;
670: }
671:
672: /*
673: * get parameters for handle
674: */
675:
676: static inline int
677: time_pps_getparams(
678: pps_handle_t handle,
679: pps_params_t *params_buf
680: )
681: {
682: pps_unit_t * punit;
683:
684: /*
685: * Check for valid arguments and get parameters.
686: */
687: if (!handle)
688: RETURN_PPS_ERRNO(EBADF);
689:
690: punit = unit_from_ppsapi_handle(handle);
691:
692: if (NULL == punit)
693: RETURN_PPS_ERRNO(EBADF);
694:
695: if (NULL == params_buf)
696: RETURN_PPS_ERRNO(EFAULT);
697:
698: *params_buf = punit->params;
699: return 0;
700: }
701:
702:
703: /*
704: * time_pps_getcap - get capabilities for handle
705: */
706: static inline int
707: time_pps_getcap(
708: pps_handle_t handle,
709: int *pmode
710: )
711: {
712: pps_unit_t * punit;
713:
714: /*
715: * Check for valid arguments and get capabilities.
716: */
717: if (!handle)
718: RETURN_PPS_ERRNO(EBADF);
719:
720: punit = unit_from_ppsapi_handle(handle);
721:
722: if (NULL == punit)
723: RETURN_PPS_ERRNO(EBADF);
724:
725: if (NULL == pmode)
726: RETURN_PPS_ERRNO(EFAULT);
727:
728: *pmode = punit->provider->caps;
729: return 0;
730: }
731:
732: /*
733: * Fetch timestamps
734: */
735:
736: static inline int
737: time_pps_fetch(
738: pps_handle_t handle,
739: const int tsformat,
740: pps_info_t * pinfo,
741: const struct timespec * ptimeout
742: )
743: {
744: pps_unit_t * punit;
745: int err;
746:
747: /*
748: * Check for valid arguments and fetch timestamps
749: */
750: if (!handle)
751: RETURN_PPS_ERRNO(EBADF);
752:
753: if (NULL == pinfo)
754: RETURN_PPS_ERRNO(EFAULT);
755:
756: punit = unit_from_ppsapi_handle(handle);
757:
758: if (NULL == punit)
759: RETURN_PPS_ERRNO(EBADF);
760:
761: err = (*punit->provider->ptime_pps_fetch)(punit,
762: punit->context,
763: tsformat,
764: pinfo,
765: ptimeout);
766:
767: if (err)
768: RETURN_PPS_ERRNO(err);
769: else
770: return 0;
771: }
772:
773: /*
774: * time_pps_kcbind - specify kernel consumer
775: *
776: * Not supported so far by Windows.
777: */
778:
779: static inline int
780: time_pps_kcbind(
781: pps_handle_t handle,
782: const int kernel_consumer,
783: const int edge, const int tsformat
784: )
785: {
786: pps_unit_t * punit;
787: int err;
788:
789: if (!handle)
790: RETURN_PPS_ERRNO(EBADF);
791:
792: punit = unit_from_ppsapi_handle(handle);
793:
794: if (NULL == punit)
795: RETURN_PPS_ERRNO(EBADF);
796:
797: err = (*punit->provider->ptime_pps_kcbind)(
798: punit,
799: punit->context,
800: kernel_consumer,
801: edge,
802: tsformat);
803:
804: if (err)
805: RETURN_PPS_ERRNO(err);
806: else
807: return 0;
808: }
809:
810:
811: #endif /* TIMEPPS_H */