sys/sys/timepps.h

   1 /*-
   2  * ----------------------------------------------------------------------------
   3  * "THE BEER-WARE LICENSE" (Revision 42):
   4  * <phk@FreeBSD.org> wrote this file.  As long as you retain this notice you
   5  * can do whatever you want with this stuff. If we meet some day, and you think
   6  * this stuff is worth it, you can buy me a beer in return.   Poul-Henning Kamp
   7  * ----------------------------------------------------------------------------
   8  *
   9  * Copyright (c) 2011 The FreeBSD Foundation
  10  * All rights reserved.
  11  *
  12  * Portions of this software were developed by Julien Ridoux at the University
  13  * of Melbourne under sponsorship from the FreeBSD Foundation.
  14  *
  15  * $FreeBSD$
  16  *
  17  * The is a FreeBSD version of the RFC 2783 API for Pulse Per Second
  18  * timing interfaces.
  19  */
  20
  21 #ifndef _SYS_TIMEPPS_H_
  22 #define _SYS_TIMEPPS_H_
  23
  24 #include <sys/_ffcounter.h>
  25 #include <sys/ioccom.h>
  26 #include <sys/time.h>
  27
  28 #define PPS_API_VERS_1  1
  29
  30 typedef int pps_handle_t;
  31
  32 typedef unsigned pps_seq_t;
  33
  34 typedef struct ntp_fp {
  35         unsigned int    integral;
  36         unsigned int    fractional;
  37 } ntp_fp_t;
  38
  39 typedef union pps_timeu {
  40         struct timespec tspec;
  41         ntp_fp_t        ntpfp;
  42         unsigned long   longpad[3];
  43 } pps_timeu_t;
  44
  45 typedef struct {
  46         pps_seq_t       assert_sequence;        /* assert event seq # */
  47         pps_seq_t       clear_sequence;         /* clear event seq # */
  48         pps_timeu_t     assert_tu;
  49         pps_timeu_t     clear_tu;
  50         int             current_mode;           /* current mode bits */
  51 } pps_info_t;
  52
  53 typedef struct {
  54         pps_seq_t       assert_sequence;        /* assert event seq # */
  55         pps_seq_t       clear_sequence;         /* clear event seq # */
  56         pps_timeu_t     assert_tu;
  57         pps_timeu_t     clear_tu;
  58         ffcounter       assert_ffcount;         /* ffcounter on assert event */
  59         ffcounter       clear_ffcount;          /* ffcounter on clear event */
  60         int             current_mode;           /* current mode bits */
  61 } pps_info_ffc_t;
  62
  63 #define assert_timestamp        assert_tu.tspec
  64 #define clear_timestamp         clear_tu.tspec
  65
  66 #define assert_timestamp_ntpfp  assert_tu.ntpfp
  67 #define clear_timestamp_ntpfp   clear_tu.ntpfp
  68
  69 typedef struct {
  70         int api_version;                        /* API version # */
  71         int mode;                               /* mode bits */
  72         pps_timeu_t assert_off_tu;
  73         pps_timeu_t clear_off_tu;
  74 } pps_params_t;
  75
  76 #define assert_offset   assert_off_tu.tspec
  77 #define clear_offset    clear_off_tu.tspec
  78
  79 #define assert_offset_ntpfp     assert_off_tu.ntpfp
  80 #define clear_offset_ntpfp      clear_off_tu.ntpfp
  81
  82
  83 #define PPS_CAPTUREASSERT       0x01
  84 #define PPS_CAPTURECLEAR        0x02
  85 #define PPS_CAPTUREBOTH         0x03
  86
  87 #define PPS_OFFSETASSERT        0x10
  88 #define PPS_OFFSETCLEAR         0x20
  89
  90 #define PPS_ECHOASSERT          0x40
  91 #define PPS_ECHOCLEAR           0x80
  92
  93 #define PPS_CANWAIT             0x100
  94 #define PPS_CANPOLL             0x200
  95
  96 #define PPS_TSFMT_TSPEC         0x1000
  97 #define PPS_TSFMT_NTPFP         0x2000
  98
  99 #define PPS_TSCLK_FBCK          0x10000
 100 #define PPS_TSCLK_FFWD          0x20000
 101 #define PPS_TSCLK_MASK          0x30000
 102
 103 #define PPS_KC_HARDPPS          0
 104 #define PPS_KC_HARDPPS_PLL      1
 105 #define PPS_KC_HARDPPS_FLL      2
 106
 107 struct pps_fetch_args {
 108         int tsformat;
 109         pps_info_t      pps_info_buf;
 110         struct timespec timeout;
 111 };
 112
 113 struct pps_fetch_ffc_args {
 114         int             tsformat;
 115         pps_info_ffc_t  pps_info_buf_ffc;
 116         struct timespec timeout;
 117 };
 118
 119 struct pps_kcbind_args {
 120         int kernel_consumer;
 121         int edge;
 122         int tsformat;
 123 };
 124
 125 #define PPS_IOC_CREATE          _IO('1', 1)
 126 #define PPS_IOC_DESTROY         _IO('1', 2)
 127 #define PPS_IOC_SETPARAMS       _IOW('1', 3, pps_params_t)
 128 #define PPS_IOC_GETPARAMS       _IOR('1', 4, pps_params_t)
 129 #define PPS_IOC_GETCAP          _IOR('1', 5, int)
 130 #define PPS_IOC_FETCH           _IOWR('1', 6, struct pps_fetch_args)
 131 #define PPS_IOC_KCBIND          _IOW('1', 7, struct pps_kcbind_args)
 132 #define PPS_IOC_FETCH_FFCOUNTER _IOWR('1', 8, struct pps_fetch_ffc_args)
 133
 134 #ifdef _KERNEL
 135
 136 struct mtx;
 137
 138 struct pps_state {
 139         /* Capture information. */
 140         struct timehands *capth;
 141         struct fftimehands *capffth;
 142         unsigned        capgen;
 143         unsigned        capcount;
 144
 145         /* pointer to mutex protecting this state, if any */
 146         struct mtx      *mtx;
 147
 148         /* State information. */
 149         pps_params_t    ppsparam;
 150         pps_info_t      ppsinfo;
 151         pps_info_ffc_t  ppsinfo_ffc;
 152         int             kcmode;
 153         int             ppscap;
 154         struct timecounter *ppstc;
 155         unsigned        ppscount[3];
 156 };
 157
 158 void pps_capture(struct pps_state *pps);
 159 void pps_event(struct pps_state *pps, int event);
 160 void pps_init(struct pps_state *pps);
 161 int pps_ioctl(unsigned long cmd, caddr_t data, struct pps_state *pps);
 162 void hardpps(struct timespec *tsp, long nsec);
 163
 164 #else /* !_KERNEL */
 165
 166 static __inline int
 167 time_pps_create(int filedes, pps_handle_t *handle)
 168 {
 169         int error;
 170
 171         *handle = -1;
 172         error = ioctl(filedes, PPS_IOC_CREATE, 0);
 173         if (error < 0)
 174                 return (-1);
 175         *handle = filedes;
 176         return (0);
 177 }
 178
 179 static __inline int
 180 time_pps_destroy(pps_handle_t handle)
 181 {
 182         return (ioctl(handle, PPS_IOC_DESTROY, 0));
 183 }
 184
 185 static __inline int
 186 time_pps_setparams(pps_handle_t handle, const pps_params_t *ppsparams)
 187 {
 188         return (ioctl(handle, PPS_IOC_SETPARAMS, ppsparams));
 189 }
 190
 191 static __inline int
 192 time_pps_getparams(pps_handle_t handle, pps_params_t *ppsparams)
 193 {
 194         return (ioctl(handle, PPS_IOC_GETPARAMS, ppsparams));
 195 }
 196
 197 static __inline int
 198 time_pps_getcap(pps_handle_t handle, int *mode)
 199 {
 200         return (ioctl(handle, PPS_IOC_GETCAP, mode));
 201 }
 202
 203 static __inline int
 204 time_pps_fetch(pps_handle_t handle, const int tsformat,
 205         pps_info_t *ppsinfobuf, const struct timespec *timeout)
 206 {
 207         int error;
 208         struct pps_fetch_args arg;
 209
 210         arg.tsformat = tsformat;
 211         if (timeout == NULL) {
 212                 arg.timeout.tv_sec = -1;
 213                 arg.timeout.tv_nsec = -1;
 214         } else
 215                 arg.timeout = *timeout;
 216         error = ioctl(handle, PPS_IOC_FETCH, &arg);
 217         *ppsinfobuf = arg.pps_info_buf;
 218         return (error);
 219 }
 220
 221 static __inline int
 222 time_pps_fetch_ffc(pps_handle_t handle, const int tsformat,
 223         pps_info_ffc_t *ppsinfobuf, const struct timespec *timeout)
 224 {
 225         struct pps_fetch_ffc_args arg;
 226         int error;
 227
 228         arg.tsformat = tsformat;
 229         if (timeout == NULL) {
 230                 arg.timeout.tv_sec = -1;
 231                 arg.timeout.tv_nsec = -1;
 232         } else {
 233                 arg.timeout = *timeout;
 234         }
 235         error = ioctl(handle, PPS_IOC_FETCH_FFCOUNTER, &arg);
 236         *ppsinfobuf = arg.pps_info_buf_ffc;
 237         return (error);
 238 }
 239
 240 static __inline int
 241 time_pps_kcbind(pps_handle_t handle, const int kernel_consumer,
 242         const int edge, const int tsformat)
 243 {
 244         struct pps_kcbind_args arg;
 245
 246         arg.kernel_consumer = kernel_consumer;
 247         arg.edge = edge;
 248         arg.tsformat = tsformat;
 249         return (ioctl(handle, PPS_IOC_KCBIND, &arg));
 250 }
 251
 252 #endif /* KERNEL */
 253
 254 #endif /* !_SYS_TIMEPPS_H_ */