timepps.h

Go to the documentation of this file.

 
/*-
 * ----------------------------------------------------------------------------
 * "THE BEER-WARE LICENSE" (Revision 42):
 * <phk@FreeBSD.org> wrote this file.  As long as you retain this notice you
 * can do whatever you want with this stuff. If we meet some day, and you think
 * this stuff is worth it, you can buy me a beer in return.   Poul-Henning Kamp
 * ----------------------------------------------------------------------------
 *
 * Copyright (c) 2011 The FreeBSD Foundation
 * All rights reserved.
 *
 * Portions of this software were developed by Julien Ridoux at the University
 * of Melbourne under sponsorship from the FreeBSD Foundation.
 *
 * The is a FreeBSD version of the RFC 2783 API for Pulse Per Second 
 * timing interfaces.  
 */
 
#ifndef _SYS_TIMEPPS_H_
#define _SYS_TIMEPPS_H_
 
#include <sys/_ffcounter.h>
#include <sys/ioccom.h>
#include <sys/time.h>
#ifdef __rtems__
#include <rtems/score/atomic.h>
#define PPS_SYNC
#define hardpps _Timecounter_Discipline
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
#endif /* __rtems__ */
 
#define PPS_API_VERS_1  1
 
typedef int pps_handle_t;   
 
#ifndef __rtems__
typedef unsigned pps_seq_t;
#else /* __rtems__ */
typedef Atomic_Uint pps_seq_t;
#endif /* __rtems__ */
 
typedef struct ntp_fp {
    unsigned int    integral;
    unsigned int    fractional;
} ntp_fp_t;
 
typedef union pps_timeu {
    struct timespec tspec;
    ntp_fp_t    ntpfp;
    unsigned long   longpad[3];
} pps_timeu_t;
 
typedef struct {
    pps_seq_t   assert_sequence;    /* assert event seq # */
    pps_seq_t   clear_sequence;     /* clear event seq # */
    pps_timeu_t assert_tu;
    pps_timeu_t clear_tu;
    int     current_mode;       /* current mode bits */
} pps_info_t;
 
typedef struct {
    pps_seq_t   assert_sequence;    /* assert event seq # */
    pps_seq_t   clear_sequence;     /* clear event seq # */
    pps_timeu_t assert_tu;
    pps_timeu_t clear_tu;
    ffcounter   assert_ffcount;     /* ffcounter on assert event */
    ffcounter   clear_ffcount;      /* ffcounter on clear event */
    int     current_mode;       /* current mode bits */
} pps_info_ffc_t;
 
#define assert_timestamp        assert_tu.tspec
#define clear_timestamp         clear_tu.tspec
 
#define assert_timestamp_ntpfp  assert_tu.ntpfp
#define clear_timestamp_ntpfp   clear_tu.ntpfp
 
typedef struct {
    int api_version;            /* API version # */
    int mode;               /* mode bits */
    pps_timeu_t assert_off_tu;
    pps_timeu_t clear_off_tu;
} pps_params_t;
 
#define assert_offset   assert_off_tu.tspec
#define clear_offset    clear_off_tu.tspec
 
#define assert_offset_ntpfp     assert_off_tu.ntpfp
#define clear_offset_ntpfp      clear_off_tu.ntpfp
 
 
#define PPS_CAPTUREASSERT   0x01
#define PPS_CAPTURECLEAR    0x02
#define PPS_CAPTUREBOTH     0x03
 
#define PPS_OFFSETASSERT    0x10
#define PPS_OFFSETCLEAR     0x20
 
#define PPS_ECHOASSERT      0x40
#define PPS_ECHOCLEAR       0x80
 
#define PPS_CANWAIT     0x100
#define PPS_CANPOLL     0x200
 
#define PPS_TSFMT_TSPEC     0x1000
#define PPS_TSFMT_NTPFP     0x2000
 
#define PPS_TSCLK_FBCK      0x10000
#define PPS_TSCLK_FFWD      0x20000
#define PPS_TSCLK_MASK      0x30000
 
#define PPS_KC_HARDPPS      0
#define PPS_KC_HARDPPS_PLL  1
#define PPS_KC_HARDPPS_FLL  2
 
struct pps_fetch_args {
    int tsformat;
    pps_info_t  pps_info_buf;
    struct timespec timeout;
};
 
struct pps_fetch_ffc_args {
    int     tsformat;
    pps_info_ffc_t  pps_info_buf_ffc;
    struct timespec timeout;
};
 
struct pps_kcbind_args {
    int kernel_consumer;
    int edge;
    int tsformat;
};
 
#define PPS_IOC_CREATE      _IO('1', 1)
#define PPS_IOC_DESTROY     _IO('1', 2)
#define PPS_IOC_SETPARAMS   _IOW('1', 3, pps_params_t)
#define PPS_IOC_GETPARAMS   _IOR('1', 4, pps_params_t)
#define PPS_IOC_GETCAP      _IOR('1', 5, int)
#define PPS_IOC_FETCH       _IOWR('1', 6, struct pps_fetch_args)
#define PPS_IOC_KCBIND      _IOW('1', 7, struct pps_kcbind_args)
#define PPS_IOC_FETCH_FFCOUNTER _IOWR('1', 8, struct pps_fetch_ffc_args)
 
#ifdef _KERNEL
 
struct mtx;
 
#define KCMODE_EDGEMASK     0x03
#define KCMODE_ABIFLAG      0x80000000 /* Internal use: abi-aware driver. */
 
#define PPS_ABI_VERSION     1
 
#define PPSFLAG_MTX_SPIN    0x01    /* Driver mtx is MTX_SPIN type. */
 
struct pps_state {
    /* Capture information. */
    struct timehands *capth;
    struct fftimehands *capffth;
    unsigned    capgen;
    unsigned    capcount;
 
    /* State information. */
    pps_params_t    ppsparam;
    pps_info_t  ppsinfo;
    pps_info_ffc_t  ppsinfo_ffc;
    int     kcmode;
    int     ppscap;
    struct timecounter *ppstc;
    unsigned    ppscount[3];
#ifdef __rtems__
    int (*wait)(struct pps_state *pps, struct timespec timeout);
 
    void (*wakeup)(struct pps_state *pps);
#endif /* __rtems__ */
    /*
     * The following fields are valid if the driver calls pps_init_abi().
     */
    uint16_t    driver_abi; /* Driver sets before pps_init_abi(). */
    uint16_t    kernel_abi; /* Kernel sets during pps_init_abi(). */
    struct mtx  *driver_mtx;    /* Optional, valid if non-NULL. */
    uint32_t    flags;
};
 
void pps_capture(struct pps_state *pps);
void pps_event(struct pps_state *pps, int event);
void pps_init(struct pps_state *pps);
void pps_init_abi(struct pps_state *pps);
int pps_ioctl(unsigned long cmd, caddr_t data, struct pps_state *pps);
void hardpps(struct timespec *tsp, long nsec);
 
#else /* !_KERNEL */
 
static __inline int
time_pps_create(int filedes, pps_handle_t *handle)
{
    int error;
 
    *handle = -1;
    error = ioctl(filedes, PPS_IOC_CREATE, 0);
    if (error < 0) 
        return (-1);
    *handle = filedes;
    return (0);
}
 
static __inline int
time_pps_destroy(pps_handle_t handle)
{
    return (ioctl(handle, PPS_IOC_DESTROY, 0));
}
 
static __inline int
time_pps_setparams(pps_handle_t handle, const pps_params_t *ppsparams)
{
    return (ioctl(handle, PPS_IOC_SETPARAMS, ppsparams));
}
 
static __inline int
time_pps_getparams(pps_handle_t handle, pps_params_t *ppsparams)
{
    return (ioctl(handle, PPS_IOC_GETPARAMS, ppsparams));
}
 
static __inline int 
time_pps_getcap(pps_handle_t handle, int *mode)
{
    return (ioctl(handle, PPS_IOC_GETCAP, mode));
}
 
static __inline int
time_pps_fetch(pps_handle_t handle, const int tsformat,
    pps_info_t *ppsinfobuf, const struct timespec *timeout)
{
    int error;
    struct pps_fetch_args arg;
 
    arg.tsformat = tsformat;
    if (timeout == NULL) {
        arg.timeout.tv_sec = -1;
        arg.timeout.tv_nsec = -1;
    } else
        arg.timeout = *timeout;
    error = ioctl(handle, PPS_IOC_FETCH, &arg);
    *ppsinfobuf = arg.pps_info_buf;
    return (error);
}
 
static __inline int
time_pps_fetch_ffc(pps_handle_t handle, const int tsformat,
    pps_info_ffc_t *ppsinfobuf, const struct timespec *timeout)
{
    struct pps_fetch_ffc_args arg;
    int error;
 
    arg.tsformat = tsformat;
    if (timeout == NULL) {
        arg.timeout.tv_sec = -1;
        arg.timeout.tv_nsec = -1;
    } else {
        arg.timeout = *timeout;
    }
    error = ioctl(handle, PPS_IOC_FETCH_FFCOUNTER, &arg);
    *ppsinfobuf = arg.pps_info_buf_ffc;
    return (error);
}
 
static __inline int
time_pps_kcbind(pps_handle_t handle, const int kernel_consumer,
    const int edge, const int tsformat)
{
    struct pps_kcbind_args arg;
 
    arg.kernel_consumer = kernel_consumer;
    arg.edge = edge;
    arg.tsformat = tsformat;
    return (ioctl(handle, PPS_IOC_KCBIND, &arg));
}
 
#endif /* KERNEL */
 
#ifdef __rtems__
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __rtems__ */
#endif /* !_SYS_TIMEPPS_H_ */