gpio_mm.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
 **
 ** 2008, 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 GPIO-MM series of Counter/Timer
    Digital I/O Cards.

   Original Author: Gordon Maclean

*/

/*
 * Each board has 10 16-bit counters and gobs of digital I/O pins.
 *
 * The implementation of a frequency counter uses 3 counters.
 * One counter on a board is used as a general timer clock.
 * Other driver modules can register with this clock to be
 * called back at periodic times.
 *
 * Therefore each board supports up to 3 frequency input
 * devices, or 9 pulse counters.
 *
 * Eventually the driver could also support a digital device,
 * for controlling all the I/O pins. Dig I/O interrupt
 * support is also available.
 *
 * So the following devices can be opened concurrently on a board:
 * 3 frequency counters, 1 dio
 * 2 frequency counters, 3 pulse counters, 1 dio
 * 1 frequency counters, 6 pulse counters, 1 dio
 * 0 frequency counters, 9 pulse counters, 1 dio
 *
 * Support for the pulse counters, dio and events has not been added yet....
 *
 * Board #0: Device table:
 * device        devname                minor number
 * freq cntr 0:  /dev/gpiomm_fcntr0     0
 * freq cntr 1:  /dev/gpiomm_fcntr1     1
 * freq cntr 2:  /dev/gpiomm_fcntr2     2
 * digital i/O:  /dev/gpiomm_dio0       3
 * pulse cntr 0: /dev/gpiomm_cntr0      4
 * pulse cntr 1: /dev/gpiomm_cntr1      5
 * pulse cntr 2: /dev/gpiomm_cntr2      6
 * pulse cntr 3: /dev/gpiomm_cntr3      7
 * pulse cntr 4: /dev/gpiomm_cntr4      8
 * pulse cntr 5: /dev/gpiomm_cntr5      9
 * pulse cntr 6: /dev/gpiomm_cntr6     10
 * pulse cntr 7: /dev/gpiomm_cntr7     11
 * pulse cntr 8: /dev/gpiomm_cntr8     12
 * event 0:      /dev/gpiomm_event0    13
 *
 * Board #1: Device table:
 * device        devname               minor number (board0 + 14)
 * freq cntr 0:  /dev/gpiomm_fcntr3    14
 * freq cntr 1:  /dev/gpiomm_fcntr4    15
 * freq cntr 2:  /dev/gpiomm_fcntr5    16
 * digital i/O:  /dev/gpiomm_dio1      17
 * pulse cntr 0: /dev/gpiomm_cntr9     18
 * pulse cntr 1: /dev/gpiomm_cntr10    19
 * pulse cntr 2: /dev/gpiomm_cntr11    10
 * pulse cntr 3: /dev/gpiomm_cntr12    21
 * pulse cntr 4: /dev/gpiomm_cntr13    22
 * pulse cntr 5: /dev/gpiomm_cntr14    23
 * pulse cntr 6: /dev/gpiomm_cntr15    24
 * pulse cntr 7: /dev/gpiomm_cntr16    25
 * pulse cntr 8: /dev/gpiomm_cntr17    26
 * event 0:      /dev/gpiomm_event1    27
 */

#ifndef NIDAS_DIAMOND_GPIO_MM_H
#define NIDAS_DIAMOND_GPIO_MM_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.
 */

struct GPIO_MM_fcntr_config
{
        int outputPeriodUsec;   // how often to report
        int numPulses;             // how many pulses to time
        int latencyUsecs;
};

struct GPIO_MM_fcntr_status
{
        unsigned int lostSamples;
        unsigned int pulseUnderflow;
        unsigned int badGateWarning;
        unsigned int badStatusWarning;
};

struct GPIO_MM_event_config
{
        int latencyUsecs;
};

struct GPIO_MM_event_status
{
        unsigned int nevents;
        unsigned int lostSamples;
};

/* 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 GPIO_MM_IOC_MAGIC 'g'

/*
 * The enumeration of IOCTLs that this driver supports.
 * See pages 130-132 of Linux Device Driver's Manual 
 */

#define GPIO_MM_FCNTR_START \
    _IOW(GPIO_MM_IOC_MAGIC,0,struct GPIO_MM_fcntr_config)
#define GPIO_MM_FCNTR_GET_STATUS \
    _IOR(GPIO_MM_IOC_MAGIC,1,struct GPIO_MM_fcntr_status)

#define GPIO_MM_EVENT_START \
    _IOW(GPIO_MM_IOC_MAGIC,2,struct GPIO_MM_event_config)
#define GPIO_MM_EVENT_GET_STATUS \
    _IOR(GPIO_MM_IOC_MAGIC,3,struct GPIO_MM_event_status)

/* Maximum IOCTL number in above values */
#define GPIO_MM_IOC_MAXNR 3

#define GPIO_MM_CT_CLOCK_HZ 20000000

#ifdef __KERNEL__
/********  Start of definitions used by driver modules only **********/

#include <linux/cdev.h>
#include <linux/device.h>
#include <nidas/linux/util.h>
#include "gpio_mm_regs.h"

typedef void (*gpio_timer_callback_func_t) (void* privateData);

struct gpio_timer_callback
{
        struct list_head list;
        gpio_timer_callback_func_t callbackFunc;
        void* privateData;
        unsigned int usecs;
        unsigned int tickModulus;
};

extern struct gpio_timer_callback *register_gpio_timer_callback(
        gpio_timer_callback_func_t callback,unsigned int usecs,
        void *privateData, int *errp);

extern long unregister_gpio_timer_callback(struct gpio_timer_callback *cb,
    int wait);

/* Size of ISA I/O space */
#define GPIO_MM_DIO_IOPORT_WIDTH    8
#define GPIO_MM_CT_IOPORT_WIDTH         16

#define MAX_GPIO_MM_BOARDS  5   // number of boards supported by driver

/* See device table in above comments */
#define GPIO_MM_MINORS_PER_BOARD 14

/* Use 3 counter timers to implement one frequency counter */
#define GPIO_MM_CNTR_PER_FCNTR 3

/* This will be 10/3=3 for GPIO-MM */
#define GPIO_MM_FCNTR_PER_BOARD (GPIO_MM_CNTR_PER_BOARD/GPIO_MM_CNTR_PER_FCNTR)

#define GPIO_MM_FCNTR_SAMPLE_QUEUE_SIZE 16

#define GPIO_MM_EVENT_SAMPLE_QUEUE_SIZE 16

/* Which counter 0-9 to use for a general purpose timer */
#define GPIO_MM_TIMER_COUNTER 9

#define CALLBACK_POOL_SIZE 64  /* number of timer callbacks we can support */

struct freq_sample
{
        dsm_sample_time_t timetag;    // timetag of sample
        dsm_sample_length_t length;       // number of bytes in data (8)
        int pulses;
        int ticks;
};

struct event_sample
{
        dsm_sample_time_t timetag;    // timetag of sample
        dsm_sample_length_t length;       // number of bytes in data (0)
        unsigned int nevents;
};

struct GPIO_MM;

struct GPIO_MM_fcntr
{
        struct GPIO_MM* brd;

        struct device* device;

        int num;                            // which freq counter on board

        struct GPIO_MM_fcntr_status status;

        char deviceName[32];

        struct cdev cdev;

        int numPulses;

        int outputPeriodUsec;

        atomic_t num_opened;                     // number of times opened

        struct gpio_timer_callback* timer_callback;

        struct dsm_sample_circ_buf samples;         // samples out of b.h.

        wait_queue_head_t rwaitq;

        struct sample_read_state read_state;

        long latencyJiffies;

        unsigned long lastWakeup;

};

struct GPIO_MM_event
{
        struct GPIO_MM* brd;

        struct device* device;

        struct GPIO_MM_event_status status;

        char deviceName[32];

        struct cdev cdev;

        atomic_t num_opened;                     // number of times opened

        struct dsm_sample_circ_buf samples;      // event samples

        wait_queue_head_t rwaitq;

        struct sample_read_state read_state;

        long latencyJiffies;

        unsigned long lastWakeup;

};

/*
 * The GPIO timer.
 */
struct GPIO_MM_timer
{
        struct GPIO_MM* brd;

        struct list_head callbackList;

        struct list_head callbackPool;

        struct list_head pendingAdds;

        struct gpio_timer_callback *pendingRemoves[CALLBACK_POOL_SIZE];

        int nPendingRemoves;

        spinlock_t callbackLock;

        unsigned int usecs;

        unsigned int irqsReceived;

        unsigned int tick;

        unsigned int tickLimit;

        int scaler;

        struct tasklet_struct tasklet;

        int callbacksChanged;

        wait_queue_head_t callbackWaitQ;

};

struct GPIO_MM
{
        int num;                        // which board in system, from 0
        unsigned int ioport_dio;         // ioport address of DIO regs
        unsigned long dio_addr;         // Base address of 8255 DIO regs

        unsigned int ioport_ct;         // ioport address of cntr/timer
        unsigned long ct_addr;        // Base address of 9513 cntr/timer regs
        int irqs[2];                // values of ISA irq A and B
        int reqirqs[2];             // requested system irqs A and B
        int cntr_used[GPIO_MM_CNTR_PER_BOARD];             // 0=unused, 1=used

    int boardID;

        unsigned char mmode_lsb[2];
        unsigned char mmode_msb[2];

        struct GPIO_MM_timer* timer;

        struct GPIO_MM_fcntr* fcntrs;

        struct GPIO_MM_event* event;

        spinlock_t reglock;

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
        struct mutex brd_mutex;         // lock for non-interrupt board ops
#else
        struct semaphore brd_mutex;     // lock for non-interrupt board ops
#endif
};

#endif

#endif