// SPDX-License-Identifier: GPL-2.0+
/*
* 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>
*/
/*
* 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 <linux/module.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/comedi/comedidev.h>
#include <linux/comedi/comedi_8254.h>
#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
/* cio-das802/16 fifo overflow */
#define CIO_ENHF 0x90
/* cio-das802/16 fifo half full int ena */
#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
#define DAS802_16_HALF_FIFO_SZ 128
struct das800_board {
const char *name;
int ai_speed;
const struct comedi_lrange *ai_range;
int resolution;
};
static const struct comedi_lrange range_das801_ai = {
9, {
BIP_RANGE(5),
BIP_RANGE(10),
UNI_RANGE(10),
BIP_RANGE(0.5),
UNI_RANGE(1),
BIP_RANGE(0.05),
UNI_RANGE(0.1),
BIP_RANGE(0.01),
UNI_RANGE(0.02)
}
};
static const struct comedi_lrange range_cio_das801_ai = {
9, {
BIP_RANGE(5),
BIP_RANGE(10),
UNI_RANGE(10),
BIP_RANGE(0.5),
UNI_RANGE(1),
BIP_RANGE(0.05),
UNI_RANGE(0.1),
BIP_RANGE(0.005),
UNI_RANGE(0.01)
}
};
static const struct comedi_lrange range_das802_ai = {
9, {
BIP_RANGE(5),
BIP_RANGE(10),
UNI_RANGE(10),
BIP_RANGE(2.5),
UNI_RANGE(5),
BIP_RANGE(1.25),
UNI_RANGE(2.5),
BIP_RANGE(0.625),
UNI_RANGE(1.25)
}
};
static const struct comedi_lrange range_das80216_ai = {
8, {
BIP_RANGE(10),
UNI_RANGE(10),
BIP_RANGE(5),
UNI_RANGE(5),
BIP_RANGE(2.5),
UNI_RANGE(2.5),
BIP_RANGE(1.25),
UNI_RANGE(1.25)
}
};
enum das800_boardinfo {
BOARD_DAS800,
BOARD_CIODAS800,
BOARD_DAS801,
BOARD_CIODAS801,
BOARD_DAS802,
BOARD_CIODAS802,
BOARD_CIODAS80216,
};
static const struct das800_board das800_boards[] = {
[BOARD_DAS800] = {
.name =
"das-800",
.ai_speed = 25000,
.ai_range = &range_bipolar5,
.resolution = 12,
},
[BOARD_CIODAS800] = {
.name =
"cio-das800",
.ai_speed = 20000,
.ai_range = &range_bipolar5,
.resolution = 12,
},
[BOARD_DAS801] = {
.name =
"das-801",
.ai_speed = 25000,
.ai_range = &range_das801_ai,
.resolution = 12,
},
[BOARD_CIODAS801] = {
.name =
"cio-das801",
.ai_speed = 20000,
.ai_range = &range_cio_das801_ai,
.resolution = 12,
},
[BOARD_DAS802] = {
.name =
"das-802",
.ai_speed = 25000,
.ai_range = &range_das802_ai,
.resolution = 12,
},
[BOARD_CIODAS802] = {
.name =
"cio-das802",
.ai_speed = 20000,
.ai_range = &range_das802_ai,
.resolution = 12,
},
[BOARD_CIODAS80216] = {
.name =
"cio-das802/16",
.ai_speed = 10000,
.ai_range = &range_das80216_ai,
.resolution = 16,
},
};
struct das800_private {
unsigned int do_bits;
/* digital output bits */
};
static void das800_ind_write(
struct comedi_device *dev,
unsigned int val,
unsigned int reg)
{
/*
* Select dev->iobase + 2 to be desired register
* then write to that register.
*/
outb(reg, dev->iobase + DAS800_GAIN);
outb(val, dev->iobase + 2);
}
static unsigned int das800_ind_read(
struct comedi_device *dev,
unsigned int reg)
{
/*
* Select dev->iobase + 7 to be desired register
* then read from that register.
*/
outb(reg, dev->iobase + DAS800_GAIN);
return inb(dev->iobase + 7);
}
static void das800_enable(
struct comedi_device *dev)
{
const struct das800_board *board = dev->board_ptr;
struct das800_private *devpriv = dev->
private;
unsigned long irq_flags;
spin_lock_irqsave(&dev->spinlock, irq_flags);
/* enable fifo-half full interrupts for cio-das802/16 */
if (board->resolution == 16)
outb(CIO_ENHF, dev->iobase + DAS800_GAIN);
/* enable hardware triggering */
das800_ind_write(dev, CONV_HCEN, CONV_CONTROL);
/* enable card's interrupt */
das800_ind_write(dev, CONTROL1_INTE | devpriv->do_bits, CONTROL1);
spin_unlock_irqrestore(&dev->spinlock, irq_flags);
}
static void das800_disable(
struct comedi_device *dev)
{
unsigned long irq_flags;
spin_lock_irqsave(&dev->spinlock, irq_flags);
/* disable hardware triggering of conversions */
das800_ind_write(dev, 0x0, CONV_CONTROL);
spin_unlock_irqrestore(&dev->spinlock, irq_flags);
}
static int das800_cancel(
struct comedi_device *dev,
struct comedi_subdevice *s)
{
das800_disable(dev);
return 0;
}
static int das800_ai_check_chanlist(
struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_cmd *cmd)
{
unsigned int chan0 = CR_CHAN(cmd->chanlist[0]);
unsigned int range0 = CR_RANGE(cmd->chanlist[0]);
int i;
for (i = 1; i < cmd->chanlist_len; i++) {
unsigned int chan = CR_CHAN(cmd->chanlist[i]);
unsigned int range = CR_RANGE(cmd->chanlist[i]);
if (chan != (chan0 + i) % s->n_chan) {
dev_dbg(dev->class_dev,
"chanlist must be consecutive, counting upwards\n");
return -EINVAL;
}
if (range != range0) {
dev_dbg(dev->class_dev,
"chanlist must all have the same gain\n");
return -EINVAL;
}
}
return 0;
}
static int das800_ai_do_cmdtest(
struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_cmd *cmd)
{
const struct das800_board *board = dev->board_ptr;
int err = 0;
/* Step 1 : check if triggers are trivially valid */
err |= comedi_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_EXT);
err |= comedi_check_trigger_src(&cmd->scan_begin_src, TRIG_FOLLOW);
err |= comedi_check_trigger_src(&cmd->convert_src,
TRIG_TIMER | TRIG_EXT);
err |= comedi_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
err |= comedi_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
if (err)
return 1;
/* Step 2a : make sure trigger sources are unique */
err |= comedi_check_trigger_is_unique(cmd->start_src);
err |= comedi_check_trigger_is_unique(cmd->convert_src);
err |= comedi_check_trigger_is_unique(cmd->stop_src);
/* Step 2b : and mutually compatible */
if (err)
return 2;
/* Step 3: check if arguments are trivially valid */
err |= comedi_check_trigger_arg_is(&cmd->start_arg, 0);
if (cmd->convert_src == TRIG_TIMER) {
err |= comedi_check_trigger_arg_min(&cmd->convert_arg,
board->ai_speed);
}
err |= comedi_check_trigger_arg_min(&cmd->chanlist_len, 1);
err |= comedi_check_trigger_arg_is(&cmd->scan_end_arg,
cmd->chanlist_len);
if (cmd->stop_src == TRIG_COUNT)
err |= comedi_check_trigger_arg_min(&cmd->stop_arg, 1);
else /* TRIG_NONE */
err |= comedi_check_trigger_arg_is(&cmd->stop_arg, 0);
if (err)
return 3;
/* step 4: fix up any arguments */
if (cmd->convert_src == TRIG_TIMER) {
unsigned int arg = cmd->convert_arg;
comedi_8254_cascade_ns_to_timer(dev->pacer, &arg, cmd->flags);
err |= comedi_check_trigger_arg_is(&cmd->convert_arg, arg);
}
if (err)
return 4;
/* Step 5: check channel list if it exists */
if (cmd->chanlist && cmd->chanlist_len > 0)
err |= das800_ai_check_chanlist(dev, s, cmd);
if (err)
return 5;
return 0;
}
static int das800_ai_do_cmd(
struct comedi_device *dev,
struct comedi_subdevice *s)
{
const struct das800_board *board = dev->board_ptr;
struct comedi_async *async = s->async;
struct comedi_cmd *cmd = &async->cmd;
unsigned int gain = CR_RANGE(cmd->chanlist[0]);
unsigned int start_chan = CR_CHAN(cmd->chanlist[0]);
unsigned int end_chan = (start_chan + cmd->chanlist_len - 1) % 8;
unsigned int scan_chans = (end_chan << 3) | start_chan;
int conv_bits;
unsigned long irq_flags;
das800_disable(dev);
spin_lock_irqsave(&dev->spinlock, irq_flags);
/* set scan limits */
das800_ind_write(dev, scan_chans, SCAN_LIMITS);
spin_unlock_irqrestore(&dev->spinlock, irq_flags);
/* set gain */
if (board->resolution == 12 && gain > 0)
gain += 0x7;
gain &= 0xf;
outb(gain, dev->iobase + DAS800_GAIN);
/* enable auto channel scan, send interrupts on end of conversion
* and set clock source to internal or external
*/
conv_bits = 0;
conv_bits |= EACS | IEOC;
if (cmd->start_src == TRIG_EXT)
conv_bits |= DTEN;
if (cmd->convert_src == TRIG_TIMER) {
conv_bits |= CASC | ITE;
comedi_8254_update_divisors(dev->pacer);
comedi_8254_pacer_enable(dev->pacer, 1, 2,
true);
}
spin_lock_irqsave(&dev->spinlock, irq_flags);
das800_ind_write(dev, conv_bits, CONV_CONTROL);
spin_unlock_irqrestore(&dev->spinlock, irq_flags);
das800_enable(dev);
return 0;
}
static unsigned int das800_ai_get_sample(
struct comedi_device *dev)
{
unsigned int lsb = inb(dev->iobase + DAS800_LSB);
unsigned int msb = inb(dev->iobase + DAS800_MSB);
return (msb << 8) | lsb;
}
static irqreturn_t das800_interrupt(
int irq,
void *d)
{
struct comedi_device *dev = d;
struct das800_private *devpriv = dev->
private;
struct comedi_subdevice *s = dev->read_subdev;
struct comedi_async *async;
struct comedi_cmd *cmd;
unsigned long irq_flags;
unsigned int status;
unsigned short val;
bool fifo_empty;
bool fifo_overflow;
int i;
status = inb(dev->iobase + DAS800_STATUS);
if (!(status & IRQ))
return IRQ_NONE;
if (!dev->attached)
return IRQ_HANDLED;
async = s->async;
cmd = &async->cmd;
spin_lock_irqsave(&dev->spinlock, irq_flags);
status = das800_ind_read(dev, CONTROL1) & STATUS2_HCEN;
/*
* Don't release spinlock yet since we want to make sure
* no one else disables hardware conversions.
*/
/* if hardware conversions are not enabled, then quit */
if (status == 0) {
spin_unlock_irqrestore(&dev->spinlock, irq_flags);
return IRQ_HANDLED;
}
for (i = 0; i < DAS802_16_HALF_FIFO_SZ; i++) {
val = das800_ai_get_sample(dev);
if (s->maxdata == 0x0fff) {
fifo_empty = !!(val & FIFO_EMPTY);
fifo_overflow = !!(val & FIFO_OVF);
}
else {
/* cio-das802/16 has no fifo empty status bit */
fifo_empty =
false;
fifo_overflow = !!(inb(dev->iobase + DAS800_GAIN) &
CIO_FFOV);
}
if (fifo_empty || fifo_overflow)
break;
if (s->maxdata == 0x0fff)
val >>= 4;
/* 12-bit sample */
val &= s->maxdata;
comedi_buf_write_samples(s, &val, 1);
if (cmd->stop_src == TRIG_COUNT &&
async->scans_done >= cmd->stop_arg) {
async->events |= COMEDI_CB_EOA;
break;
}
}
if (fifo_overflow) {
spin_unlock_irqrestore(&dev->spinlock, irq_flags);
async->events |= COMEDI_CB_ERROR;
comedi_handle_events(dev, s);
return IRQ_HANDLED;
}
if (!(async->events & COMEDI_CB_CANCEL_MASK)) {
/*
* Re-enable card's interrupt.
* We already have spinlock, so indirect addressing is safe
*/
das800_ind_write(dev, CONTROL1_INTE | devpriv->do_bits,
CONTROL1);
spin_unlock_irqrestore(&dev->spinlock, irq_flags);
}
else {
/* otherwise, stop taking data */
spin_unlock_irqrestore(&dev->spinlock, irq_flags);
das800_disable(dev);
}
comedi_handle_events(dev, s);
return IRQ_HANDLED;
}
static int das800_ai_eoc(
struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn,
unsigned long context)
{
unsigned int status;
status = inb(dev->iobase + DAS800_STATUS);
if ((status & BUSY) == 0)
return 0;
return -EBUSY;
}
static int das800_ai_insn_read(
struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn,
unsigned int *data)
{
struct das800_private *devpriv = dev->
private;
unsigned int chan = CR_CHAN(insn->chanspec);
unsigned int range = CR_RANGE(insn->chanspec);
unsigned long irq_flags;
unsigned int val;
int ret;
int i;
das800_disable(dev);
/* set multiplexer */
spin_lock_irqsave(&dev->spinlock, irq_flags);
das800_ind_write(dev, chan | devpriv->do_bits, CONTROL1);
spin_unlock_irqrestore(&dev->spinlock, irq_flags);
/* set gain / range */
if (s->maxdata == 0x0fff && range)
range += 0x7;
range &= 0xf;
outb(range, dev->iobase + DAS800_GAIN);
udelay(5);
for (i = 0; i < insn->n; i++) {
/* trigger conversion */
outb_p(0, dev->iobase + DAS800_MSB);
ret = comedi_timeout(dev, s, insn, das800_ai_eoc, 0);
if (ret)
return ret;
val = das800_ai_get_sample(dev);
if (s->maxdata == 0x0fff)
val >>= 4;
/* 12-bit sample */
data[i] = val & s->maxdata;
}
return insn->n;
}
static int das800_di_insn_bits(
struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn,
unsigned int *data)
{
data[1] = (inb(dev->iobase + DAS800_STATUS) >> 4) & 0x7;
return insn->n;
}
static int das800_do_insn_bits(
struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn,
unsigned int *data)
{
struct das800_private *devpriv = dev->
private;
unsigned long irq_flags;
if (comedi_dio_update_state(s, data)) {
devpriv->do_bits = s->state << 4;
spin_lock_irqsave(&dev->spinlock, irq_flags);
das800_ind_write(dev, CONTROL1_INTE | devpriv->do_bits,
CONTROL1);
spin_unlock_irqrestore(&dev->spinlock, irq_flags);
}
data[1] = s->state;
return insn->n;
}
static const struct das800_board *das800_probe(
struct comedi_device *dev)
{
const struct das800_board *board = dev->board_ptr;
int index = board ? board - das800_boards : -EINVAL;
int id_bits;
unsigned long irq_flags;
/*
* The dev->board_ptr will be set by comedi_device_attach() if the
* board name provided by the user matches a board->name in this
* driver. If so, this function sanity checks the id_bits to verify
* that the board is correct.
*
* If the dev->board_ptr is not set, the user is trying to attach
* an unspecified board to this driver. In this case the id_bits
* are used to 'probe' for the correct dev->board_ptr.
*/
spin_lock_irqsave(&dev->spinlock, irq_flags);
id_bits = das800_ind_read(dev, ID) & 0x3;
spin_unlock_irqrestore(&dev->spinlock, irq_flags);
switch (id_bits) {
case 0x0:
if (index == BOARD_DAS800 || index == BOARD_CIODAS800)
return board;
index = BOARD_DAS800;
break;
case 0x2:
if (index == BOARD_DAS801 || index == BOARD_CIODAS801)
return board;
index = BOARD_DAS801;
break;
case 0x3:
if (index == BOARD_DAS802 || index == BOARD_CIODAS802 ||
index == BOARD_CIODAS80216)
return board;
index = BOARD_DAS802;
break;
default:
dev_dbg(dev->class_dev,
"Board model: 0x%x (unknown)\n",
id_bits);
return NULL;
}
dev_dbg(dev->class_dev,
"Board model (probed): %s series\n",
das800_boards[index].name);
return &das800_boards[index];
}
static int das800_attach(
struct comedi_device *dev,
struct comedi_devconfig *it)
{
const struct das800_board *board;
struct das800_private *devpriv;
struct comedi_subdevice *s;
unsigned int irq = it->options[1];
unsigned long irq_flags;
int ret;
devpriv = comedi_alloc_devpriv(dev,
sizeof(*devpriv));
if (!devpriv)
return -ENOMEM;
ret = comedi_request_region(dev, it->options[0], 0x8);
if (ret)
return ret;
board = das800_probe(dev);
if (!board)
return -ENODEV;
dev->board_ptr = board;
dev->board_name = board->name;
if (irq > 1 && irq <= 7) {
ret = request_irq(irq, das800_interrupt, 0,
"das800",
dev);
if (ret == 0)
dev->irq = irq;
}
dev->pacer = comedi_8254_io_alloc(dev->iobase + DAS800_8254,
I8254_OSC_BASE_1MHZ, I8254_IO8, 0);
if (IS_ERR(dev->pacer))
return PTR_ERR(dev->pacer);
ret = comedi_alloc_subdevices(dev, 3);
if (ret)
return ret;
/* Analog Input subdevice */
s = &dev->subdevices[0];
dev->read_subdev = s;
s->type = COMEDI_SUBD_AI;
s->subdev_flags = SDF_READABLE | SDF_GROUND;
s->n_chan = 8;
s->maxdata = (1 << board->resolution) - 1;
s->range_table = board->ai_range;
s->insn_read = das800_ai_insn_read;
if (dev->irq) {
s->subdev_flags |= SDF_CMD_READ;
s->len_chanlist = 8;
s->do_cmdtest = das800_ai_do_cmdtest;
s->do_cmd = das800_ai_do_cmd;
s->cancel = das800_cancel;
}
/* Digital Input subdevice */
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_insn_bits;
/* Digital Output subdevice */
s = &dev->subdevices[2];
s->type = COMEDI_SUBD_DO;
s->subdev_flags = SDF_WRITABLE;
s->n_chan = 4;
s->maxdata = 1;
s->range_table = &range_digital;
s->insn_bits = das800_do_insn_bits;
das800_disable(dev);
/* initialize digital out channels */
spin_lock_irqsave(&dev->spinlock, irq_flags);
das800_ind_write(dev, CONTROL1_INTE | devpriv->do_bits, CONTROL1);
spin_unlock_irqrestore(&dev->spinlock, irq_flags);
return 0;
};
static struct comedi_driver driver_das800 = {
.driver_name =
"das800",
.module = THIS_MODULE,
.attach = das800_attach,
.detach = comedi_legacy_detach,
.num_names = ARRAY_SIZE(das800_boards),
.board_name = &das800_boards[0].name,
.offset =
sizeof(
struct das800_board),
};
module_comedi_driver(driver_das800);
MODULE_AUTHOR(
"Comedi https://www.comedi.org");
MODULE_DESCRIPTION(
"Comedi low-level driver");
MODULE_LICENSE(
"GPL");
