Staging: comedi: add das800 driver

/*

    comedi/drivers/das800.c

    Driver for Keitley das800 series boards and compatibles

    Copyright (C) 2000 Frank Mori Hess <fmhess@users.sourceforge.net>

    COMEDI - Linux Control and Measurement Device Interface

    Copyright (C) 2000 David A. Schleef <ds@schleef.org>

    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.

    You should have received a copy of the GNU General Public License

    along with this program; if not, write to the Free Software

    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

************************************************************************

*/

/*

Driver: das800

Description: Keithley Metrabyte DAS800 (& compatibles)

Author: Frank Mori Hess <fmhess@users.sourceforge.net>

Devices: [Keithley Metrabyte] DAS-800 (das-800), DAS-801 (das-801),

  DAS-802 (das-802),

  [Measurement Computing] CIO-DAS800 (cio-das800),

  CIO-DAS801 (cio-das801), CIO-DAS802 (cio-das802),

  CIO-DAS802/16 (cio-das802/16)

Status: works, cio-das802/16 untested - email me if you have tested it

Configuration options:

  [0] - I/O port base address

  [1] - IRQ (optional, required for timed or externally triggered conversions)

Notes:

	IRQ can be omitted, although the cmd interface will not work without it.

	All entries in the channel/gain list must use the same gain and be

	consecutive channels counting upwards in channel number (these are

	hardware limitations.)

	I've never tested the gain setting stuff since I only have a

	DAS-800 board with fixed gain.

	The cio-das802/16 does not have a fifo-empty status bit!  Therefore

	only fifo-half-full transfers are possible with this card.

*/

/*

cmd triggers supported:

	start_src:      TRIG_NOW | TRIG_EXT

	scan_begin_src: TRIG_FOLLOW

	scan_end_src:   TRIG_COUNT

	convert_src:    TRIG_TIMER | TRIG_EXT

	stop_src:       TRIG_NONE | TRIG_COUNT

*/

#include "../comedidev.h"

#include <linux/ioport.h>

#include <linux/delay.h>

#include "8253.h"

#include "comedi_fc.h"

#define DAS800_SIZE           8

#define TIMER_BASE            1000

#define N_CHAN_AI             8	// number of analog input channels

/* Registers for the das800 */

#define DAS800_LSB            0

#define   FIFO_EMPTY            0x1

#define   FIFO_OVF              0x2

#define DAS800_MSB            1

#define DAS800_CONTROL1       2

#define   CONTROL1_INTE         0x8

#define DAS800_CONV_CONTROL   2

#define   ITE                   0x1

#define   CASC                  0x2

#define   DTEN                  0x4

#define   IEOC                  0x8

#define   EACS                  0x10

#define   CONV_HCEN             0x80

#define DAS800_SCAN_LIMITS    2

#define DAS800_STATUS         2

#define   IRQ                   0x8

#define   BUSY                  0x80

#define DAS800_GAIN           3

#define   CIO_FFOV              0x8	// fifo overflow for cio-das802/16

#define   CIO_ENHF              0x90	// interrupt fifo half full for cio-das802/16

#define   CONTROL1              0x80

#define   CONV_CONTROL          0xa0

#define   SCAN_LIMITS           0xc0

#define   ID                    0xe0

#define DAS800_8254           4

#define DAS800_STATUS2        7

#define   STATUS2_HCEN          0x80

#define   STATUS2_INTE          0X20

#define DAS800_ID             7

typedef struct das800_board_struct {

	const char *name;

	int ai_speed;

	const comedi_lrange *ai_range;

	int resolution;

} das800_board;

//analog input ranges

static const comedi_lrange range_das800_ai = {

	1,

	{

			RANGE(-5, 5),

		}

};

static const comedi_lrange range_das801_ai = {

	9,

	{

			RANGE(-5, 5),

			RANGE(-10, 10),

			RANGE(0, 10),

			RANGE(-0.5, 0.5),

			RANGE(0, 1),

			RANGE(-0.05, 0.05),

			RANGE(0, 0.1),

			RANGE(-0.01, 0.01),

			RANGE(0, 0.02),

		}

};

static const comedi_lrange range_cio_das801_ai = {

	9,

	{

			RANGE(-5, 5),

			RANGE(-10, 10),

			RANGE(0, 10),

			RANGE(-0.5, 0.5),

			RANGE(0, 1),

			RANGE(-0.05, 0.05),

			RANGE(0, 0.1),

			RANGE(-0.005, 0.005),

			RANGE(0, 0.01),

		}

};

static const comedi_lrange range_das802_ai = {

	9,

	{

			RANGE(-5, 5),

			RANGE(-10, 10),

			RANGE(0, 10),

			RANGE(-2.5, 2.5),

			RANGE(0, 5),

			RANGE(-1.25, 1.25),

			RANGE(0, 2.5),

			RANGE(-0.625, 0.625),

			RANGE(0, 1.25),

		}

};

static const comedi_lrange range_das80216_ai = {

	8,

	{

			RANGE(-10, 10),

			RANGE(0, 10),

			RANGE(-5, 5),

			RANGE(0, 5),

			RANGE(-2.5, 2.5),

			RANGE(0, 2.5),

			RANGE(-1.25, 1.25),

			RANGE(0, 1.25),

		}

};

enum { das800, ciodas800, das801, ciodas801, das802, ciodas802, ciodas80216 };

static const das800_board das800_boards[] = {

	{

	      name:	"das-800",

	      ai_speed:25000,

	      ai_range:&range_das800_ai,

	      resolution:12,

		},

	{

	      name:	"cio-das800",

	      ai_speed:20000,

	      ai_range:&range_das800_ai,

	      resolution:12,

		},

	{

	      name:	"das-801",

	      ai_speed:25000,

	      ai_range:&range_das801_ai,

	      resolution:12,

		},

	{

	      name:	"cio-das801",

	      ai_speed:20000,

	      ai_range:&range_cio_das801_ai,

	      resolution:12,

		},

	{

	      name:	"das-802",

	      ai_speed:25000,

	      ai_range:&range_das802_ai,

	      resolution:12,

		},

	{

	      name:	"cio-das802",

	      ai_speed:20000,

	      ai_range:&range_das802_ai,

	      resolution:12,

		},

	{

	      name:	"cio-das802/16",

	      ai_speed:10000,

	      ai_range:&range_das80216_ai,

	      resolution:16,

		},

};

/*

 * Useful for shorthand access to the particular board structure

 */

#define thisboard ((const das800_board *)dev->board_ptr)

typedef struct {

	volatile unsigned int count;	/* number of data points left to be taken */

	volatile int forever;	/* flag indicating whether we should take data forever */

	unsigned int divisor1;	/* value to load into board's counter 1 for timed conversions */

	unsigned int divisor2;	/* value to load into board's counter 2 for timed conversions */

	volatile int do_bits;	/* digital output bits */

} das800_private;

#define devpriv ((das800_private *)dev->private)

static int das800_attach(comedi_device * dev, comedi_devconfig * it);

static int das800_detach(comedi_device * dev);

static int das800_cancel(comedi_device * dev, comedi_subdevice * s);

static comedi_driver driver_das800 = {

      driver_name:"das800",

      module:THIS_MODULE,

      attach:das800_attach,

      detach:das800_detach,

      num_names:sizeof(das800_boards) / sizeof(das800_board),

      board_name:&das800_boards[0].name,

      offset:sizeof(das800_board),

};

static irqreturn_t das800_interrupt(int irq, void *d PT_REGS_ARG);

static void enable_das800(comedi_device * dev);

static void disable_das800(comedi_device * dev);

static int das800_ai_do_cmdtest(comedi_device * dev, comedi_subdevice * s,

	comedi_cmd * cmd);

static int das800_ai_do_cmd(comedi_device * dev, comedi_subdevice * s);

static int das800_ai_rinsn(comedi_device * dev, comedi_subdevice * s,

	comedi_insn * insn, lsampl_t * data);

static int das800_di_rbits(comedi_device * dev, comedi_subdevice * s,

	comedi_insn * insn, lsampl_t * data);

static int das800_do_wbits(comedi_device * dev, comedi_subdevice * s,

	comedi_insn * insn, lsampl_t * data);

static int das800_probe(comedi_device * dev);

static int das800_set_frequency(comedi_device * dev);

/* checks and probes das-800 series board type */

static int das800_probe(comedi_device * dev)

{

	int id_bits;

	unsigned long irq_flags;

	int board;

	// 'comedi spin lock irqsave' disables even rt interrupts, we use them to protect indirect addressing

	comedi_spin_lock_irqsave(&dev->spinlock, irq_flags);

	outb(ID, dev->iobase + DAS800_GAIN);	/* select base address + 7 to be ID register */

	id_bits = inb(dev->iobase + DAS800_ID) & 0x3;	/* get id bits */

	comedi_spin_unlock_irqrestore(&dev->spinlock, irq_flags);

	board = thisboard - das800_boards;

	switch (id_bits) {

	case 0x0:

		if (board == das800) {

			printk(" Board model: DAS-800\n");

			return board;

		}

		if (board == ciodas800) {

			printk(" Board model: CIO-DAS800\n");

			return board;

		}

		printk(" Board model (probed): DAS-800\n");

		return das800;

		break;

	case 0x2:

		if (board == das801) {

			printk(" Board model: DAS-801\n");

			return board;

		}

		if (board == ciodas801) {

			printk(" Board model: CIO-DAS801\n");

			return board;

		}

		printk(" Board model (probed): DAS-801\n");

		return das801;

		break;

	case 0x3:

		if (board == das802) {

			printk(" Board model: DAS-802\n");

			return board;

		}

		if (board == ciodas802) {

			printk(" Board model: CIO-DAS802\n");

			return board;

		}

		if (board == ciodas80216) {

			printk(" Board model: CIO-DAS802/16\n");

			return board;

		}

		printk(" Board model (probed): DAS-802\n");

		return das802;

		break;

	default:

		printk(" Board model: probe returned 0x%x (unknown)\n",

			id_bits);

		return board;

		break;

	}

	return -1;

}

/*

 * A convenient macro that defines init_module() and cleanup_module(),

 * as necessary.

 */

COMEDI_INITCLEANUP(driver_das800);

/* interrupt service routine */

static irqreturn_t das800_interrupt(int irq, void *d PT_REGS_ARG)

{

	short i;		/* loop index */

	sampl_t dataPoint = 0;

	comedi_device *dev = d;

	comedi_subdevice *s = dev->read_subdev;	/* analog input subdevice */

	comedi_async *async;

	int status;

	unsigned long irq_flags;

	static const int max_loops = 128;	// half-fifo size for cio-das802/16

	// flags

	int fifo_empty = 0;

	int fifo_overflow = 0;

	status = inb(dev->iobase + DAS800_STATUS);

	/* if interrupt was not generated by board or driver not attached, quit */

	if (!(status & IRQ))

		return IRQ_NONE;

	if (!(dev->attached))

		return IRQ_HANDLED;

	/* wait until here to initialize async, since we will get null dereference

	 * if interrupt occurs before driver is fully attached!

	 */

	async = s->async;

	// if hardware conversions are not enabled, then quit

	comedi_spin_lock_irqsave(&dev->spinlock, irq_flags);

	outb(CONTROL1, dev->iobase + DAS800_GAIN);	/* select base address + 7 to be STATUS2 register */

	status = inb(dev->iobase + DAS800_STATUS2) & STATUS2_HCEN;

	/* don't release spinlock yet since we want to make sure noone else disables hardware conversions */

	if (status == 0) {

		comedi_spin_unlock_irqrestore(&dev->spinlock, irq_flags);

		return IRQ_HANDLED;

	}

	/* loop while card's fifo is not empty (and limit to half fifo for cio-das802/16) */

	for (i = 0; i < max_loops; i++) {

		/* read 16 bits from dev->iobase and dev->iobase + 1 */

		dataPoint = inb(dev->iobase + DAS800_LSB);

		dataPoint += inb(dev->iobase + DAS800_MSB) << 8;

		if (thisboard->resolution == 12) {

			fifo_empty = dataPoint & FIFO_EMPTY;

			fifo_overflow = dataPoint & FIFO_OVF;

			if (fifo_overflow)

				break;

		} else {

			fifo_empty = 0;	// cio-das802/16 has no fifo empty status bit

		}

		if (fifo_empty) {

			break;

		}

		/* strip off extraneous bits for 12 bit cards */

		if (thisboard->resolution == 12)

			dataPoint = (dataPoint >> 4) & 0xfff;

		/* if there are more data points to collect */

		if (devpriv->count > 0 || devpriv->forever == 1) {

			/* write data point to buffer */

			cfc_write_to_buffer(s, dataPoint);

			if (devpriv->count > 0)

				devpriv->count--;

		}

	}

	async->events |= COMEDI_CB_BLOCK;

	/* check for fifo overflow */

	if (thisboard->resolution == 12) {

		fifo_overflow = dataPoint & FIFO_OVF;

		// else cio-das802/16

	} else {

		fifo_overflow = inb(dev->iobase + DAS800_GAIN) & CIO_FFOV;

	}

	if (fifo_overflow) {

		comedi_spin_unlock_irqrestore(&dev->spinlock, irq_flags);

		comedi_error(dev, "DAS800 FIFO overflow");

		das800_cancel(dev, dev->subdevices + 0);

		async->events |= COMEDI_CB_ERROR | COMEDI_CB_EOA;

		comedi_event(dev, s);

		async->events = 0;

		return IRQ_HANDLED;

	}

	if (devpriv->count > 0 || devpriv->forever == 1) {

		/* Re-enable card's interrupt.

		 * We already have spinlock, so indirect addressing is safe */

		outb(CONTROL1, dev->iobase + DAS800_GAIN);	/* select dev->iobase + 2 to be control register 1 */

		outb(CONTROL1_INTE | devpriv->do_bits,

			dev->iobase + DAS800_CONTROL1);

		comedi_spin_unlock_irqrestore(&dev->spinlock, irq_flags);

		/* otherwise, stop taking data */

	} else {

		comedi_spin_unlock_irqrestore(&dev->spinlock, irq_flags);

		disable_das800(dev);	/* diable hardware triggered conversions */

		async->events |= COMEDI_CB_EOA;

	}

	comedi_event(dev, s);

	async->events = 0;

	return IRQ_HANDLED;

}

static int das800_attach(comedi_device * dev, comedi_devconfig * it)

{

	comedi_subdevice *s;

	unsigned long iobase = it->options[0];

	unsigned int irq = it->options[1];

	unsigned long irq_flags;

	int board;

	printk("comedi%d: das800: io 0x%lx", dev->minor, iobase);

	if (irq) {

		printk(", irq %u", irq);

	}

	printk("\n");

	/* allocate and initialize dev->private */

	if (alloc_private(dev, sizeof(das800_private)) < 0)

		return -ENOMEM;

	if (iobase == 0) {

		printk("io base address required for das800\n");

		return -EINVAL;

	}

	/* check if io addresses are available */

	if (!request_region(iobase, DAS800_SIZE, "das800")) {

		printk("I/O port conflict\n");

		return -EIO;

	}

	dev->iobase = iobase;

	board = das800_probe(dev);

	if (board < 0) {

		printk("unable to determine board type\n");

		return -ENODEV;

	}

	dev->board_ptr = das800_boards + board;

	/* grab our IRQ */

	if (irq == 1 || irq > 7) {

		printk("irq out of range\n");

		return -EINVAL;

	}

	if (irq) {

		if (comedi_request_irq(irq, das800_interrupt, 0, "das800", dev)) {

			printk("unable to allocate irq %u\n", irq);

			return -EINVAL;

		}

	}

	dev->irq = irq;

	dev->board_name = thisboard->name;

	if (alloc_subdevices(dev, 3) < 0)

		return -ENOMEM;

	/* analog input subdevice */

	s = dev->subdevices + 0;

	dev->read_subdev = s;

	s->type = COMEDI_SUBD_AI;

	s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_CMD_READ;

	s->n_chan = 8;

	s->len_chanlist = 8;

	s->maxdata = (1 << thisboard->resolution) - 1;

	s->range_table = thisboard->ai_range;

	s->do_cmd = das800_ai_do_cmd;

	s->do_cmdtest = das800_ai_do_cmdtest;

	s->insn_read = das800_ai_rinsn;

	s->cancel = das800_cancel;

	/* di */

	s = dev->subdevices + 1;

	s->type = COMEDI_SUBD_DI;

	s->subdev_flags = SDF_READABLE;

	s->n_chan = 3;

	s->maxdata = 1;

	s->range_table = &range_digital;

	s->insn_bits = das800_di_rbits;

	/* do */

	s = dev->subdevices + 2;

	s->type = COMEDI_SUBD_DO;

	s->subdev_flags = SDF_WRITABLE | SDF_READABLE;

	s->n_chan = 4;

	s->maxdata = 1;

	s->range_table = &range_digital;

	s->insn_bits = das800_do_wbits;

	disable_das800(dev);

	/* initialize digital out channels */

	comedi_spin_lock_irqsave(&dev->spinlock, irq_flags);

	outb(CONTROL1, dev->iobase + DAS800_GAIN);	/* select dev->iobase + 2 to be control register 1 */

	outb(CONTROL1_INTE | devpriv->do_bits, dev->iobase + DAS800_CONTROL1);

	comedi_spin_unlock_irqrestore(&dev->spinlock, irq_flags);

	return 0;

};

static int das800_detach(comedi_device * dev)

{

	printk("comedi%d: das800: remove\n", dev->minor);

	/* only free stuff if it has been allocated by _attach */

	if (dev->iobase)

		release_region(dev->iobase, DAS800_SIZE);

	if (dev->irq)

		comedi_free_irq(dev->irq, dev);

	return 0;

};

static int das800_cancel(comedi_device * dev, comedi_subdevice * s)

{

	devpriv->forever = 0;

	devpriv->count = 0;

	disable_das800(dev);

	return 0;

}

/* enable_das800 makes the card start taking hardware triggered conversions */

static void enable_das800(comedi_device * dev)

{

	unsigned long irq_flags;

	comedi_spin_lock_irqsave(&dev->spinlock, irq_flags);

	// enable fifo-half full interrupts for cio-das802/16

	if (thisboard->resolution == 16)

		outb(CIO_ENHF, dev->iobase + DAS800_GAIN);

	outb(CONV_CONTROL, dev->iobase + DAS800_GAIN);	/* select dev->iobase + 2 to be conversion control register */

	outb(CONV_HCEN, dev->iobase + DAS800_CONV_CONTROL);	/* enable hardware triggering */

	outb(CONTROL1, dev->iobase + DAS800_GAIN);	/* select dev->iobase + 2 to be control register 1 */

	outb(CONTROL1_INTE | devpriv->do_bits, dev->iobase + DAS800_CONTROL1);	/* enable card's interrupt */

	comedi_spin_unlock_irqrestore(&dev->spinlock, irq_flags);

}

/* disable_das800 stops hardware triggered conversions */

static void disable_das800(comedi_device * dev)

{

	unsigned long irq_flags;

	comedi_spin_lock_irqsave(&dev->spinlock, irq_flags);

	outb(CONV_CONTROL, dev->iobase + DAS800_GAIN);	/* select dev->iobase + 2 to be conversion control register */

	outb(0x0, dev->iobase + DAS800_CONV_CONTROL);	/* disable hardware triggering of conversions */

	comedi_spin_unlock_irqrestore(&dev->spinlock, irq_flags);

}

static int das800_ai_do_cmdtest(comedi_device * dev, comedi_subdevice * s,

	comedi_cmd * cmd)

{

	int err = 0;

	int tmp;

	int gain, startChan;

	int i;

	/* step 1: make sure trigger sources are trivially valid */

	tmp = cmd->start_src;

	cmd->start_src &= TRIG_NOW | TRIG_EXT;

	if (!cmd->start_src || tmp != cmd->start_src)

		err++;

	tmp = cmd->scan_begin_src;

	cmd->scan_begin_src &= TRIG_FOLLOW;

	if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)

		err++;

	tmp = cmd->convert_src;

	cmd->convert_src &= TRIG_TIMER | TRIG_EXT;

	if (!cmd->convert_src || tmp != cmd->convert_src)

		err++;

	tmp = cmd->scan_end_src;

	cmd->scan_end_src &= TRIG_COUNT;

	if (!cmd->scan_end_src || tmp != cmd->scan_end_src)

		err++;

	tmp = cmd->stop_src;

	cmd->stop_src &= TRIG_COUNT | TRIG_NONE;

	if (!cmd->stop_src || tmp != cmd->stop_src)

		err++;

	if (err)

		return 1;

	/* step 2: make sure trigger sources are unique and mutually compatible */

	if (cmd->start_src != TRIG_NOW && cmd->start_src != TRIG_EXT)

		err++;

	if (cmd->convert_src != TRIG_TIMER && cmd->convert_src != TRIG_EXT)

		err++;

	if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE)

		err++;

	if (err)

		return 2;

	/* step 3: make sure arguments are trivially compatible */

	if (cmd->start_arg != 0) {

		cmd->start_arg = 0;

		err++;

	}

	if (cmd->convert_src == TRIG_TIMER) {

		if (cmd->convert_arg < thisboard->ai_speed) {

			cmd->convert_arg = thisboard->ai_speed;

			err++;

		}

	}

	if (!cmd->chanlist_len) {

		cmd->chanlist_len = 1;

		err++;

	}

	if (cmd->scan_end_arg != cmd->chanlist_len) {

		cmd->scan_end_arg = cmd->chanlist_len;

		err++;

	}

	if (cmd->stop_src == TRIG_COUNT) {

		if (!cmd->stop_arg) {

			cmd->stop_arg = 1;

			err++;

		}

	} else {		/* TRIG_NONE */

		if (cmd->stop_arg != 0) {

			cmd->stop_arg = 0;

			err++;

		}

	}

	if (err)

		return 3;

	/* step 4: fix up any arguments */

	if (cmd->convert_src == TRIG_TIMER) {

		tmp = cmd->convert_arg;

		/* calculate counter values that give desired timing */

		i8253_cascade_ns_to_timer_2div(TIMER_BASE, &(devpriv->divisor1),

			&(devpriv->divisor2), &(cmd->convert_arg),

			cmd->flags & TRIG_ROUND_MASK);

		if (tmp != cmd->convert_arg)

			err++;

	}

	if (err)

		return 4;

	// check channel/gain list against card's limitations

	if (cmd->chanlist) {

		gain = CR_RANGE(cmd->chanlist[0]);

		startChan = CR_CHAN(cmd->chanlist[0]);

		for (i = 1; i < cmd->chanlist_len; i++) {

			if (CR_CHAN(cmd->chanlist[i]) !=

				(startChan + i) % N_CHAN_AI) {

				comedi_error(dev,

					"entries in chanlist must be consecutive channels, counting upwards\n");

				err++;

			}

			if (CR_RANGE(cmd->chanlist[i]) != gain) {

				comedi_error(dev,

					"entries in chanlist must all have the same gain\n");

				err++;

			}

		}

	}

	if (err)

		return 5;

	return 0;

}