util.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.
 **
 ********************************************************************
*/
/* 
   Utility functions for nidas device drivers.
 
   Original Author: Gordon Maclean
 
*/
 
#ifndef NIDAS_LINUX_NIDAS_UTIL_H
#define NIDAS_LINUX_NIDAS_UTIL_H
 
#if defined(__KERNEL__)
 
#include "types.h"
#include <linux/types.h>
#include <linux/wait.h>
#include <linux/fs.h>
 
#include <linux/circ_buf.h>
#include <linux/ktime.h>
#include <linux/version.h>
 
/* 
 * https://elixir.bootlin.com/linux/latest/source is a useful site for searching
 * through kernel versions for an indentifier.
 *
 * Vulcans are running 2.6.21 kernel, ACCESS_ONCE and READ_ONCE are not defined
 * Vipers/titans: 3.16.0, ACCESS_ONCE is defined, but READ_ONCE is not
 * 3.18.13: first appearance of READ_ONCE
 */
#ifndef READ_ONCE
#ifdef ACCESS_ONCE
#define READ_ONCE(x) ACCESS_ONCE(x)
#else
/* def of ACCESS_ONCE in include/linux/compiler.h in 3.16 */
#define READ_ONCE(x) (*(volatile typeof(x) *)&(x))
#endif
#endif
 
#ifndef WRITE_ONCE
#ifdef ACCESS_ONCE
#define WRITE_ONCE(x,val) ACCESS_ONCE(x) = (val)
#else
#define WRITE_ONCE(x,val) (*(volatile typeof(x) *)&(x)) = (val)
#endif
#endif
 
struct dsm_sample_circ_buf {
        struct dsm_sample **buf;
        int head;
        int tail;
        int size;
        void** pages;
        int npages;
};
 
#define GET_HEAD(cbuf,size) \
        ({\
         (CIRC_SPACE((cbuf).head,READ_ONCE((cbuf).tail),(size)) > 0 ? \
          (cbuf).buf[(cbuf).head] : 0);\
         })
 
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,13,0)
#define INCREMENT_HEAD(cbuf,size) \
        smp_store_release(&(cbuf).head, ((cbuf).head + 1) & ((size) - 1))
#else
#define INCREMENT_HEAD(cbuf,size) \
        do { smp_wmb(); (cbuf).head = ((cbuf).head + 1) & ((size) - 1); } while (0)
#endif
 
#define NEXT_HEAD(cbuf,size) \
        (INCREMENT_HEAD(cbuf,size), GET_HEAD(cbuf,size))
 
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,13,0)
#define GET_TAIL(cbuf,size) \
        ({\
         int tmp = CIRC_CNT(smp_load_acquire(&(cbuf).head),(cbuf).tail,size);\
         (tmp > 0 ? (cbuf).buf[(cbuf).tail] : 0);\
         })
#else
#define GET_TAIL(cbuf,size) \
        ({\
         int tmp = CIRC_CNT(READ_ONCE((cbuf).head),(cbuf).tail,size);\
         smp_read_barrier_depends();\
         (tmp > 0 ? (cbuf).buf[(cbuf).tail] : 0);\
         })
#endif
 
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,13,0)
#define INCREMENT_TAIL(cbuf,size) \
        smp_store_release(&(cbuf).tail, ((cbuf).tail + 1) & ((size) - 1))
 
#else
#define INCREMENT_TAIL(cbuf,size) \
        do { smp_mb(); (cbuf).tail = ((cbuf).tail + 1) & ((size) - 1); } while(0)
#endif
 
#define EMPTY_CIRC_BUF(cbuf) \
        do { (cbuf).tail = (cbuf).head = 0; smp_mb(); } while(0)
 
extern int alloc_dsm_circ_buf(struct dsm_sample_circ_buf* c,size_t dlen,int blen);
 
extern void free_dsm_circ_buf(struct dsm_sample_circ_buf* c);
 
extern int realloc_dsm_circ_buf(struct dsm_sample_circ_buf* c,size_t dlen,int blen);
 
extern void init_dsm_circ_buf(struct dsm_sample_circ_buf* c);
 
#if LINUX_VERSION_CODE < KERNEL_VERSION(3,17,0)
typedef struct timespec thiskernel_timespec_t;
#else
typedef struct timespec64 thiskernel_timespec_t;
#endif
 
/*
 * Return system time in a thiskernel_timespec_t.
 * ktime_get_real_ts64 first appears in 3.17
 */
inline void getSystemTimeTs(thiskernel_timespec_t *ts)
{
#if LINUX_VERSION_CODE < KERNEL_VERSION(3,17,0)
        ktime_get_real_ts(ts);
#else
        ktime_get_real_ts64(ts);
#endif
}
 
/*
 * Return time in milliseconds since 00:00 UTC.
 */
inline dsm_sample_time_t getSystemTimeMsecs(void)
{
        thiskernel_timespec_t ts;
        getSystemTimeTs(&ts);
        /* BITS_PER_LONG seems to be defined in all kernels, but
         * __BITS_PER_LONG isn't defined in 2.6 kernels.
         * Use __BITS_PER_LONG if exporting a .h to user space. */
#if BITS_PER_LONG == 32 && LINUX_VERSION_CODE >= KERNEL_VERSION(3,17,0)
    /* do_div changes dividend in place, returns remainder */
        return do_div(ts.tv_sec, SECS_PER_DAY) * MSECS_PER_SEC +
        ts.tv_nsec / NSECS_PER_MSEC;
#else
        return (ts.tv_sec % SECS_PER_DAY) * MSECS_PER_SEC +
                ts.tv_nsec / NSECS_PER_MSEC;
#endif
}
 
/*
 * Return time in tenths of milliseconds since 00:00 UTC.
 */
inline dsm_sample_time_t getSystemTimeTMsecs(void)
{
        thiskernel_timespec_t ts;
        getSystemTimeTs(&ts);
#if BITS_PER_LONG == 32 && LINUX_VERSION_CODE >= KERNEL_VERSION(3,17,0)
    /* do_div changes dividend in place, returns remainder */
        return do_div(ts.tv_sec, SECS_PER_DAY) * TMSECS_PER_SEC +
        ts.tv_nsec / NSECS_PER_TMSEC;
#else
        return (ts.tv_sec % SECS_PER_DAY) * TMSECS_PER_SEC +
                ts.tv_nsec / NSECS_PER_TMSEC;
#endif
}
 
struct sample_read_state
{
        char* samplePtr;
        unsigned int bytesLeft;
};
 
inline int sample_remains(const struct sample_read_state* state)
{
        return state->bytesLeft != 0;
}
 
extern ssize_t
nidas_circbuf_read(struct file *filp, char __user* buf, size_t count,
                struct dsm_sample_circ_buf* cbuf, struct sample_read_state* state,
                wait_queue_head_t* readq);
 
extern ssize_t
nidas_circbuf_read_nowait(struct file *filp, char __user* buf, size_t count,
                struct dsm_sample_circ_buf* cbuf, struct sample_read_state* state);
 
struct screen_timetag_data
{
        unsigned int dtTmsec;
 
        unsigned int dtUsec;
 
        unsigned int nptsCalc;
 
        dsm_sample_time_t tt0;
 
        int nDt;
 
        unsigned int samplesPerDay;
 
#ifdef DO_TIMETAG_ERROR_AVERAGE
        int nSum;
 
        int errAvg;
#else
 
        int nmin;
 
        int nptsMin;
 
        int tdiffmin;
 
#endif
 
 
};
 
extern void screen_timetag_init(struct screen_timetag_data* td,
        int deltaT_Usec, int adjustUsec);
 
extern dsm_sample_time_t screen_timetag(struct screen_timetag_data* td,
        dsm_sample_time_t tt);
 
#endif  /* KERNEL */
 
#endif