irigclock.h

Go to the documentation of this file.

/* -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 8; tab-width: 8; -*- */
/* vim: set shiftwidth=8 softtabstop=8 expandtab: */
/*
 ********************************************************************
 ** NIDAS: NCAR In-situ Data Acquistion Software
 **
 ** 2007, Copyright University Corporation for Atmospheric Research
 **
 ** This program is free software; you can redistribute it and/or modify
 ** it under the terms of the GNU General Public License as published by
 ** the Free Software Foundation; either version 2 of the License, or
 ** (at your option) any later version.
 **
 ** This program is distributed in the hope that it will be useful,
 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 ** GNU General Public License for more details.
 **
 ** The LICENSE.txt file accompanying this software contains
 ** a copy of the GNU General Public License. If it is not found,
 ** write to the Free Software Foundation, Inc.,
 ** 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 **
 ********************************************************************
*/
/* irigclock.h

   Class for interfacing the PC104-SG time and frequency processor.

   Original Author: Mike Spowart

*/

#ifndef IRIGCLOCK_H
#define IRIGCLOCK_H

#if defined(__KERNEL__)
#  include <linux/time.h>
#  include "util.h"
#else
#  include <sys/time.h>
#endif

#include "types.h"

enum irigClockRates {
        IRIG_0_1_HZ, IRIG_1_HZ,  IRIG_2_HZ,  IRIG_4_HZ,  IRIG_5_HZ,
        IRIG_10_HZ, IRIG_20_HZ, IRIG_25_HZ, IRIG_50_HZ,
        IRIG_100_HZ, IRIG_NUM_RATES, IRIG_ZERO_HZ = IRIG_NUM_RATES,
};

static inline enum irigClockRates irigClockRateToEnum(unsigned int value)
{
        /* Round up to the next highest enumerated poll rate. */
        if      (value == 0)     return IRIG_0_1_HZ;
        else if (value <= 1)     return IRIG_1_HZ;
        else if (value <= 2)     return IRIG_2_HZ;
        else if (value <= 4)     return IRIG_4_HZ;
        else if (value <= 5)     return IRIG_5_HZ;
        else if (value <= 10)    return IRIG_10_HZ;
        else if (value <= 20)    return IRIG_20_HZ;
        else if (value <= 25)    return IRIG_25_HZ;
        else if (value <= 50)    return IRIG_50_HZ;
        else if (value <= 100)   return IRIG_100_HZ;
        else                     return IRIG_NUM_RATES;  /* invalid value given */
}

static inline unsigned int irigClockEnumToRate(enum irigClockRates value)
{
        static unsigned int rate[] = {0, 1, 2, 4, 5, 10, 20, 25, 50, 100, 0};    
        return rate[value];       
}

/*
 * fields in struct timeval on 64 bit machine are 64 bits,
 * so declare our own 2x32 bit timeval struct, for backward
 * compatibility of old samples and IRIG_GET/SET_CLOCK ioctls.
 */
struct timeval32 {
        int tv_sec;
        int tv_usec;
};

struct dsm_clock_data {
        struct timeval32 tval;
        unsigned char status;
        char end[];
};

struct dsm_clock_data_2 {
        struct timeval32 irigt;
        struct timeval32 unixt;
        unsigned char status;
        unsigned char seqnum;
        unsigned char syncToggles;
        unsigned char clockAdjusts;
        unsigned char max100HzBacklog;
        char end[];
};

struct dsm_clock_data_3 {
        int64_t irigt;
        int64_t unixt;
        unsigned char dummystatus;
        unsigned char status;
        unsigned char seqnum;
        unsigned char syncToggles;
        unsigned char clockAdjusts;
        unsigned char max100HzBacklog;
        char end[];
};

struct dsm_clock_sample {
        dsm_sample_time_t timetag;      /* timetag of sample */
        dsm_sample_length_t length;     /* number of bytes in data */
        struct dsm_clock_data data;     /* must be no padding between
                                                 * length and data! */
};

struct dsm_clock_sample_2 {
        dsm_sample_time_t timetag;      /* timetag of sample */
        dsm_sample_length_t length;     /* number of bytes in data */
        struct dsm_clock_data_2 data;           /* must be no padding between
                                                 * length and data! */
};

struct dsm_clock_sample_3 {
        dsm_sample_time_t timetag;      /* timetag of sample */
        dsm_sample_length_t length;     /* number of bytes in data */
        struct dsm_clock_data_3 data;           /* must be no padding between
                                                 * length and data! */
};
#define IRIG_MAX_DT_DIFF 20
#define IRIG_MIN_DT_DIFF -20

struct pc104sg_status {

        uint32_t syncToggles;

        uint32_t softwareClockResets;

        uint32_t slews[IRIG_MAX_DT_DIFF - IRIG_MIN_DT_DIFF + 1];

        unsigned char statusOR;
};

#define IRIG_IOC_MAGIC 'I'  /* Unique(ish) char for IRIG ioctls */

#define IRIG_OPEN       _IO(IRIG_IOC_MAGIC, 0)
#define IRIG_CLOSE      _IO(IRIG_IOC_MAGIC, 1)
#define IRIG_GET_STATUS     _IOR(IRIG_IOC_MAGIC, 2, struct pc104sg_status)
#define IRIG_GET_CLOCK      _IOR(IRIG_IOC_MAGIC, 3, struct timeval32)
#define IRIG_SET_CLOCK      _IOW(IRIG_IOC_MAGIC, 4, struct timeval32)
#define IRIG_OVERRIDE_CLOCK _IOW(IRIG_IOC_MAGIC, 5, struct timeval32)
#define IRIG_GET_CLOCK64    _IOR(IRIG_IOC_MAGIC, 6, int64_t)
#define IRIG_SET_CLOCK64    _IOW(IRIG_IOC_MAGIC, 7, int64_t)

/**********  Start of symbols used by kernel modules **********/

#if defined(__KERNEL__)

#include <linux/ioctl.h>
#include <linux/wait.h>

struct irigTime {
        int year;   /* actual year, eg: 2004 */
        int yday;   /* day of year, 1-366 */
        int hour;
        int min;
        int sec;
        int msec;
        int usec;
        int nsec;
};


/*
 * Clock ticker kept in RAM for reading (not writing!) by other kernel
 * modules via the GET_MSEC_CLOCK and GET_TMSEC_CLOCK macros.
 */
extern int TMsecClock[];
extern int ReadClock;

#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,13,0)
#define GET_TMSEC_CLOCK \
        ({\
         int tmp = smp_load_acquire(&ReadClock);\
         TMsecClock[tmp];\
         })
#else
#define GET_TMSEC_CLOCK \
        ({\
         int tmp = READ_ONCE(ReadClock);\
         smp_read_barrier_depends();\
         TMsecClock[tmp];\
         })
#endif

#define GET_MSEC_CLOCK (GET_TMSEC_CLOCK/10)

extern int get_msec_clock_resolution(void);

extern void irig_clock_gettime(thiskernel_timespec_t* tp);

typedef void irig_callback_func(void* privateData);

struct irig_callback {
        struct list_head list;
        irig_callback_func* callback;
        irig_callback_func* resyncCallback;
        void* privateData;
        enum irigClockRates rate;
};

extern struct irig_callback* register_irig_callback(
                irig_callback_func* func,
                irig_callback_func* resync,
                enum irigClockRates rate,
                void* privateData,int *errp);

extern int unregister_irig_callback(struct irig_callback*);

extern int flush_irig_callbacks(void);

int setRate2Output(int rate);

#endif  /* defined(__KERNEL__) */

#endif