dmd_mmat.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.
 **
 ********************************************************************
*/
/*
 
   Driver for Diamond Systems Corp MM AT series of Analog IO boards
 
   Original Author: Gordon Maclean
 
*/
 
#ifndef NIDAS_DIAMOND_DMD_MMAT_H
#define NIDAS_DIAMOND_DMD_MMAT_H
 
#include <nidas/linux/util.h>
#include <nidas/linux/a2d.h>
 
#ifndef __KERNEL__
/* User programs need this for the _IO macros, but kernel
 * modules get their's elsewhere.
 */
#include <sys/ioctl.h>
#include <sys/types.h>
#endif
 
/* This header is also included from user-side code that
 * wants to get the values of the ioctl commands, and
 * the definition of the structures.
 */
 
#define MAX_DMMAT_BOARDS    4   // number of boards supported by driver
#define MAX_DMMAT_A2D_CHANNELS 32   // max num A/D channels per card
#define DMMAT_D2A_OUTPUTS_PER_BRD 4
#define MAX_DMMAT_D2A_OUTPUTS (MAX_DMMAT_BOARDS * DMMAT_D2A_OUTPUTS_PER_BRD)
 
struct DMMAT_A2D_Status
{
        unsigned int missedSamples;
        unsigned int fifoOverflows; // A2D FIFO has overflowed (error)
        unsigned int fifoUnderflows;    // A2D FIFO less than expected level (error)
        unsigned int fifoEmpty;         // A2D FIFO empty (error)
};
 
/* Supported board types */
/*
 * Warning: the code for DMM16AT has not been tested in many years, and
 * much has changed in this driver since then. Until it is tested,
 * assume it is broken.
 */
#define DMM16AT_BOARD   0
#define DMM32AT_BOARD   1
#define DMM32XAT_BOARD  2
/* The 32DXAT version of the board has a 16 bit D2A. According to the manual
 * it is supposed to have jumpers called DAC_SZ0/1, which allow one to configure
 * it to behave like a DMM32XAT with a 12 bit D2A. However, they are soldered
 * 0 ohm resistors, not jumpers, and so there is no way for the user to force
 * the card to behave like a 32XAT. In the user forum at diamondsystems.com ,
 * Diamond says, as of Aug 2009, that they are working on a FPGA fix to allow
 * the user to control the D2A behaviour. This FPGA change isn't in the 2 cards
 * that we have on the GV CVI system. There is no easy way for the driver to
 * detect which card is present, so the user must pass this board type integer
 * to the driver.
 */
#define DMM32DXAT_BOARD 3
 
/* Pick a character as the magic number of your driver.
 * It isn't strictly necessary that it be distinct between
 * all modules on the system, but is a good idea. With
 * distinct magic numbers one can catch a user sending
 * an ioctl to the wrong device.
 */
#define DMMAT_IOC_MAGIC 'd'
 
/*
 * The enumeration of IOCTLs that this driver supports.
 * See pages 130-132 of Linux Device Driver's Manual
 */
 
#define DMMAT_A2D_GET_STATUS \
    _IOR(DMMAT_IOC_MAGIC,0,struct DMMAT_A2D_Status)
#define DMMAT_START      _IO(DMMAT_IOC_MAGIC,1)
#define DMMAT_STOP       _IO(DMMAT_IOC_MAGIC,2)
#define DMMAT_A2D_DO_AUTOCAL    _IO(DMMAT_IOC_MAGIC,3)
 
#define DMMAT_CNTR_START \
        _IOW(DMMAT_IOC_MAGIC,4,struct DMMAT_CNTR_Config)
#define DMMAT_CNTR_STOP       _IO(DMMAT_IOC_MAGIC,5)
#define DMMAT_CNTR_GET_STATUS \
        _IOR(DMMAT_IOC_MAGIC,6,struct DMMAT_CNTR_Status)
 
#define DMMAT_D2A_GET_NOUTPUTS \
        _IO(DMMAT_IOC_MAGIC,7)
#define DMMAT_D2A_GET_CONVERSION \
        _IOR(DMMAT_IOC_MAGIC,8,struct DMMAT_D2A_Conversion)
#define DMMAT_D2A_SET \
        _IOW(DMMAT_IOC_MAGIC,9,struct DMMAT_D2A_Outputs)
#define DMMAT_D2A_GET \
        _IOR(DMMAT_IOC_MAGIC,10,struct DMMAT_D2A_Outputs)
#define DMMAT_ADD_WAVEFORM \
        _IOW(DMMAT_IOC_MAGIC, 11, struct D2A_Waveform)
#define DMMAT_D2A_SET_CONFIG \
        _IOW(DMMAT_IOC_MAGIC, 12, struct D2A_Config)
 
#define DMMAT_IOC_MAXNR 12
 
#define DMMAT_STATUS_A2D_BUSY       0x80    // 1=conv or scan in progress
#define DMMAT_STATUS_TIMER_INT      0x40    // interrupt from timer 0
#define DMMAT_STATUS_SINGLE_ENDED   0x20    // 1=SE jumpered, else diff.
#define DMMAT_STATUS_A2D_INT        0x10    // interrupt from A2D
#define DMMAT_STATUS_CHAN_MASK      0x0f    // current channel
 
enum dmmat_d2a_jumpers
{
        DMMAT_D2A_UNI_5,        // unipolar, 0-5V
        DMMAT_D2A_UNI_10,       // unipolar, 0-10V
        DMMAT_D2A_BI_5,         // bipolar, -5-5V
        DMMAT_D2A_BI_10,        // bipolar, -10-10V
        DMMAT_D2A_BI_2P5        // bipolar, -2.5-2.5V
};
 
 
struct DMMAT_CNTR_Config
{
        int msecPeriod;         // how long to count for
};
 
struct DMMAT_CNTR_Status
{
        unsigned int lostSamples;
        unsigned int irqsReceived;
};
 
struct DMMAT_D2A_Conversion
{
        int vmin[MAX_DMMAT_D2A_OUTPUTS];
        int vmax[MAX_DMMAT_D2A_OUTPUTS];
        int cmin[MAX_DMMAT_D2A_OUTPUTS];
        int cmax[MAX_DMMAT_D2A_OUTPUTS];
};
 
struct DMMAT_D2A_Outputs
{
        int active[MAX_DMMAT_D2A_OUTPUTS];     // 1=set, 0=ignore
        int counts[MAX_DMMAT_D2A_OUTPUTS];      // counts value
        int nout;
};
 
struct D2A_Config
{
    int waveformRate;
};
 
struct D2A_Waveform
{
    int channel;
 
    int size;
 
    int point[0];
};
 
#ifdef __cplusplus
 
#include <cstdlib>
class D2A_WaveformWrapper {
public:
        D2A_WaveformWrapper(int channel, int size): _waveform(0),
                _csize(sizeof(struct D2A_Waveform) + sizeof(_waveform->point[0]) * size)
        {
                _waveform = (struct D2A_Waveform*) ::malloc(_csize);
                _waveform->channel = channel;
                _waveform->size = size;
        }
 
        ~D2A_WaveformWrapper() { ::free(_waveform); }
 
        D2A_Waveform* c_ptr() { return _waveform; }
 
        int c_size() const { return _csize; }
private:
        struct D2A_Waveform* _waveform;
        int _csize;
        D2A_WaveformWrapper(const D2A_WaveformWrapper&);
        D2A_WaveformWrapper& operator=(const D2A_WaveformWrapper&);
};
 
#endif
 
#ifdef __KERNEL__
/********  Start of definitions used by the driver module only **********/
 
#include <linux/version.h>
 
#include <linux/cdev.h>
#include <linux/device.h>
// #include <linux/timer.h>
 
#include <linux/workqueue.h>
 
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
#define STRUCT_MUTEX struct mutex
#else
#define STRUCT_MUTEX struct semaphore
#endif
 
/* Size of ISA I/O space (both MM16AT and MM32XAT) */
#define DMMAT_IOPORT_WIDTH  16
 
/*
 * Board #0
 * A2D: 1 device, minor number 0, /dev/dmmat_a2d0
 * CNTR: 1 device, minor number 1 /dev/dmmat_cntr0
 * D2A: 1 device, minor number 2, /dev/dmmat_d2a0
 * D2D: 1 device, minor number 3, /dev/dmmat_d2d0
 *
 * Board #1
 * A2D: 1 device, minor number 4, /dev/dmmat_a2d1
 * CNTR: 1 device, minor number 5 /dev/dmmat_cntr1
 * D2A: 1 device, minor number 6, /dev/dmmat_d2a1
 * D2D: 1 device, minor number 7, /dev/dmmat_d2d1
 */
#define DMMAT_DEVICES_PER_BOARD 4  // See the next entries
#define DMMAT_DEVICES_A2D_MINOR 0
#define DMMAT_DEVICES_CNTR_MINOR 1
#define DMMAT_DEVICES_D2A_MINOR 2
#define DMMAT_DEVICES_D2D_MINOR 3
 
/* Max size of D2A waveform on DMM32XAT and DMM32DXAT */
#define DMMAT_D2A_WAVEFORM_SIZE 1024
 
/* Number of samples in the output circular buffer for
 * the pulse counter device. Size of the circular
 * TODO: make this dynamic, dependent on the
 * requested sample rate.
 */
#define DMMAT_CNTR_QUEUE_SIZE 16
 
/* defines for analog config. These values are common to MM16AT and MM32XAT */
#define DMMAT_UNIPOLAR      0x04
#define DMMAT_BIPOLAR       0x00
#define DMMAT_RANGE_10V     0x08
#define DMMAT_RANGE_5V      0x00
 
#define DMMAT_GAIN_1        0x00
#define DMMAT_GAIN_2        0x01
#define DMMAT_GAIN_4        0x02
#define DMMAT_GAIN_8        0x03
 
/* all boards support this rate for the input to counter 1 */
#define DMMAT_CNTR1_INPUT_RATE  10000000
 
/* defines for 8254 clock */
#define DMMAT_8254_CNTR_0       0x00    // select counter 0
#define DMMAT_8254_CNTR_1       0x40    // select counter 1
#define DMMAT_8254_CNTR_2       0x80    // select counter 2
#define DMMAT_8254_RWCMD        0xc0    // read-back command
 
#define DMMAT_8254_LATCH        0x00    // latch the counter
#define DMMAT_8254_RW_LS        0x10    // next r/w is least signif byte
#define DMMAT_8254_RW_MS        0x20    // next r/w is most signif byte
#define DMMAT_8254_RW_LS_MS     0x30    // next r/w is least followed by most
 
#define DMMAT_8254_MODE_0   0x00
#define DMMAT_8254_MODE_1   0x02
#define DMMAT_8254_MODE_2   0x04
#define DMMAT_8254_MODE_3   0x06
#define DMMAT_8254_MODE_4   0x08
#define DMMAT_8254_MODE_5   0x0a
 
struct a2d_sample
{
        dsm_sample_time_t timetag;    // timetag of sample
        dsm_sample_length_t length;       // number of bytes in data
        short data[MAX_DMMAT_A2D_CHANNELS+1];
};
 
struct counter12
{
        int inputRate;
        int outputRate;
        atomic_t userCount;
        spinlock_t lock;
};
 
struct DMMAT
{
        int num;
 
        unsigned int ioport;
 
        unsigned long addr;
 
        unsigned long addr16;
 
        int irq;
 
        int irq_users[2];
 
        int type;
 
        unsigned long itr_status_reg;
 
        unsigned long itr_ack_reg;
 
        unsigned char itr_mask;
 
        unsigned char ad_itr_mask;
 
        unsigned char cntr_itr_mask;
 
        unsigned char itr_ack_val;
 
        unsigned char itr_ctrl_val;
 
        struct counter12 clock12;       // counter/timer 1/2
        struct DMMAT_A2D* a2d;          // pointer to A2D device struct
        struct DMMAT_CNTR* cntr;        // pointer to CNTR device struct
        struct DMMAT_D2A* d2a;          // pointer to D2A device struct
        struct DMMAT_D2D* d2d;          // pointer to D2D device struct
 
        int (*setClock1InputRate)(struct DMMAT* brd,int rate);
 
        spinlock_t reglock;
 
        STRUCT_MUTEX irqreq_mutex;      // when setting up irq handler
};
 
struct a2d_bh_data
{
        struct a2d_sample saveSample;
};
 
struct waveform_bh_data
{
        struct short_sample* owsamp[MAX_DMMAT_A2D_CHANNELS];
 
        int waveSampCntr;
 
};
 
struct DMMAT_A2D
{
        struct DMMAT* brd;
 
        struct device* device;
 
        struct DMMAT_A2D_Status status;
 
        enum a2dmode { A2D_NORMAL, A2D_WAVEFORM } mode;
 
        char deviceName[2][32];
 
        struct cdev cdev;
 
        STRUCT_MUTEX mutex;
 
        atomic_t num_opened;                     // number of times opened
        atomic_t running;                       // a2d is running
 
        int overflow;
 
        void (*start)(struct DMMAT_A2D* a2d);   // a2d start method
        void (*stop)(struct DMMAT_A2D* a2d);    // a2d stop method
        int  (*getFifoLevel)(struct DMMAT_A2D* a2d);
 
        int  (*getA2DThreshold)(struct DMMAT_A2D* a2d);
 
        int  (*getNumA2DChannels)(struct DMMAT_A2D* a2d);
        int  (*selectA2DChannels)(struct DMMAT_A2D* a2d);
        int  (*getConvRateSetting)(struct DMMAT_A2D* a2d, unsigned char* val);
        int  (*getGainSetting)(struct DMMAT_A2D* a2d,int gain, int bipolar,
                        unsigned char* val);
        void (*resetFifo)(struct DMMAT_A2D* a2d);
        void (*waitForA2DSettle)(struct DMMAT_A2D* a2d);
 
        int gain;
 
        int bipolar;
 
        int lowChan;
 
        int highChan;
 
        int nchanScanned;
 
        unsigned char gainConvSetting;
 
        int scanRate;
 
        int scanDeltaT;
 
        int maxFifoThreshold;
 
        int fifoThreshold;
 
        int totalOutputRate;
 
        struct work_struct worker;
 
        struct work_struct waveform_worker;
 
        struct a2d_bh_data bh_data;
 
        struct waveform_bh_data waveform_bh_data;
 
        struct dsm_sample_circ_buf fifo_samples;
 
        struct dsm_sample_circ_buf samples;
 
        wait_queue_head_t read_queue;
 
        struct sample_read_state read_state;
 
        int nfilters;
 
        struct short_filter_info* filters;
 
        int waveformChannels[MAX_DMMAT_A2D_CHANNELS];
 
        int nwaveformChannels;
 
        int wavesize;
 
        int latencyMsecs;
 
        int latencyJiffies;
 
        unsigned long lastWakeup;
 
        struct screen_timetag_data ttdata;
 
        unsigned int nLargeTimeAdj;
 
};
 
struct cntr_sample
{
        dsm_sample_time_t timetag;
        dsm_sample_length_t length;
        unsigned int data;
};
 
struct DMMAT_CNTR
{
        struct DMMAT* brd;
 
        struct device* device;
 
        struct cdev cdev;
 
        char deviceName[32];
 
        atomic_t running;
 
        atomic_t num_opened;
 
        STRUCT_MUTEX mutex;
 
        struct DMMAT_CNTR_Status status;
 
        struct timer_list timer;
 
        int  (*start)(struct DMMAT_CNTR* cntr); // cntr start method
 
        void (*stop)(struct DMMAT_CNTR* cntr);  // cntr stop method
 
        unsigned int rolloverSum;     // current counter sum
 
        int jiffiePeriod;                       // how often to wake up
                                                // and create an output
 
        int firstTime;                          // first count is bad
 
        atomic_t shutdownTimer;                      // set to 1 to stop counting
 
        int lastVal;                            // previous value in the
                                                // counter register
 
        struct dsm_sample_circ_buf samples;    // samples for read method
 
        struct sample_read_state read_state;
 
        wait_queue_head_t read_queue;           // user read & poll methods
                                                // wait on this queue
 
};
 
struct DMMAT_D2A
{
        struct DMMAT* brd;
 
        struct device* device;
 
        struct cdev cdev;
 
        char deviceName[32];
 
        atomic_t num_opened;                     // number of times opened
 
        atomic_t waveform_running;
 
        STRUCT_MUTEX waveform_mutex;
 
        struct DMMAT_D2A_Outputs outputs;
 
        int (*setD2A)(struct DMMAT_D2A* d2a,struct DMMAT_D2A_Outputs* set,int i);
 
        int (*addWaveform)(struct DMMAT_D2A* d2a, struct D2A_Waveform* waveform);
 
        int (*loadWaveforms)(struct DMMAT_D2A* d2a);
 
        void (*startWaveforms)(struct DMMAT_D2A* d2a);
 
        void (*stopWaveforms)(struct DMMAT_D2A* d2a);
 
        int vmin;
 
        int vmax;
 
        int cmin;
 
        int cmax;
 
        int waveformRate;
 
        struct D2A_Waveform *waveforms[DMMAT_D2A_OUTPUTS_PER_BRD];
 
        int nWaveforms;
 
        int wavesize;
 
};
 
struct DMMAT_D2D
{
    struct DMMAT* brd;
 
        struct device* device;
 
    struct cdev cdev;
 
    char deviceName[32];
 
    void (*start)(struct DMMAT_D2D* d2d);
    void (*stop)(struct DMMAT_D2D* d2d);
 
        STRUCT_MUTEX mutex;
 
        atomic_t num_opened;
};
 
#endif
 
#endif