| /* |
| * comedi/drivers/das08.c |
| * comedi driver for common DAS08 support (used by ISA/PCI/PCMCIA drivers) |
| * |
| * COMEDI - Linux Control and Measurement Device Interface |
| * Copyright (C) 2000 David A. Schleef <ds@schleef.org> |
| * Copyright (C) 2001,2002,2003 Frank Mori Hess <fmhess@users.sourceforge.net> |
| * Copyright (C) 2004 Salvador E. Tropea <set@users.sf.net> <set@ieee.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: das08 |
| * Description: DAS-08 compatible boards |
| * Devices: various, see das08_isa, das08_cs, and das08_pci drivers |
| * Author: Warren Jasper, ds, Frank Hess |
| * Updated: Fri, 31 Aug 2012 19:19:06 +0100 |
| * Status: works |
| * |
| * This driver is used by the das08_isa, das08_cs, and das08_pci |
| * drivers to provide the common support for the DAS-08 hardware. |
| * |
| * The driver doesn't support asynchronous commands, since the |
| * cheap das08 hardware doesn't really support them. |
| */ |
| |
| #include <linux/delay.h> |
| |
| #include "../comedidev.h" |
| |
| #include "8255.h" |
| #include "8253.h" |
| #include "das08.h" |
| |
| /* |
| cio-das08.pdf |
| |
| "isa-das08" |
| |
| 0 a/d bits 0-3 start 8 bit |
| 1 a/d bits 4-11 start 12 bit |
| 2 eoc, ip1-3, irq, mux op1-4, inte, mux |
| 3 unused unused |
| 4567 8254 |
| 89ab 8255 |
| |
| requires hard-wiring for async ai |
| |
| */ |
| |
| #define DAS08_LSB 0 |
| #define DAS08_MSB 1 |
| #define DAS08_TRIG_12BIT 1 |
| #define DAS08_STATUS 2 |
| #define DAS08_EOC (1<<7) |
| #define DAS08_IRQ (1<<3) |
| #define DAS08_IP(x) (((x)>>4)&0x7) |
| #define DAS08_CONTROL 2 |
| #define DAS08_MUX_MASK 0x7 |
| #define DAS08_MUX(x) ((x) & DAS08_MUX_MASK) |
| #define DAS08_INTE (1<<3) |
| #define DAS08_DO_MASK 0xf0 |
| #define DAS08_OP(x) (((x) << 4) & DAS08_DO_MASK) |
| |
| /* |
| cio-das08jr.pdf |
| |
| "das08/jr-ao" |
| |
| 0 a/d bits 0-3 unused |
| 1 a/d bits 4-11 start 12 bit |
| 2 eoc, mux mux |
| 3 di do |
| 4 unused ao0_lsb |
| 5 unused ao0_msb |
| 6 unused ao1_lsb |
| 7 unused ao1_msb |
| |
| */ |
| |
| #define DAS08JR_DIO 3 |
| #define DAS08JR_AO_LSB(x) ((x) ? 6 : 4) |
| #define DAS08JR_AO_MSB(x) ((x) ? 7 : 5) |
| |
| /* |
| cio-das08_aox.pdf |
| |
| "das08-aoh" |
| "das08-aol" |
| "das08-aom" |
| |
| 0 a/d bits 0-3 start 8 bit |
| 1 a/d bits 4-11 start 12 bit |
| 2 eoc, ip1-3, irq, mux op1-4, inte, mux |
| 3 mux, gain status gain control |
| 4567 8254 |
| 8 unused ao0_lsb |
| 9 unused ao0_msb |
| a unused ao1_lsb |
| b unused ao1_msb |
| 89ab |
| cdef 8255 |
| */ |
| |
| #define DAS08AO_GAIN_CONTROL 3 |
| #define DAS08AO_GAIN_STATUS 3 |
| |
| #define DAS08AO_AO_LSB(x) ((x) ? 0xa : 8) |
| #define DAS08AO_AO_MSB(x) ((x) ? 0xb : 9) |
| #define DAS08AO_AO_UPDATE 8 |
| |
| /* gainlist same as _pgx_ below */ |
| |
| static const struct comedi_lrange range_das08_pgl = { 9, { |
| BIP_RANGE(10), |
| BIP_RANGE(5), |
| BIP_RANGE(2.5), |
| BIP_RANGE(1.25), |
| BIP_RANGE(0.625), |
| UNI_RANGE(10), |
| UNI_RANGE(5), |
| UNI_RANGE(2.5), |
| UNI_RANGE(1.25) |
| } |
| }; |
| |
| static const struct comedi_lrange range_das08_pgh = { 12, { |
| BIP_RANGE(10), |
| BIP_RANGE(5), |
| BIP_RANGE(1), |
| BIP_RANGE(0.5), |
| BIP_RANGE(0.1), |
| BIP_RANGE(0.05), |
| BIP_RANGE(0.01), |
| BIP_RANGE(0.005), |
| UNI_RANGE(10), |
| UNI_RANGE(1), |
| UNI_RANGE(0.1), |
| UNI_RANGE(0.01), |
| } |
| }; |
| |
| static const struct comedi_lrange range_das08_pgm = { 9, { |
| BIP_RANGE(10), |
| BIP_RANGE(5), |
| BIP_RANGE(0.5), |
| BIP_RANGE(0.05), |
| BIP_RANGE(0.01), |
| UNI_RANGE(10), |
| UNI_RANGE(1), |
| UNI_RANGE(0.1), |
| UNI_RANGE(0.01) |
| } |
| }; /* |
| cio-das08jr.pdf |
| |
| "das08/jr-ao" |
| |
| 0 a/d bits 0-3 unused |
| 1 a/d bits 4-11 start 12 bit |
| 2 eoc, mux mux |
| 3 di do |
| 4 unused ao0_lsb |
| 5 unused ao0_msb |
| 6 unused ao1_lsb |
| 7 unused ao1_msb |
| |
| */ |
| |
| static const struct comedi_lrange *const das08_ai_lranges[] = { |
| &range_unknown, |
| &range_bipolar5, |
| &range_das08_pgh, |
| &range_das08_pgl, |
| &range_das08_pgm, |
| }; |
| |
| static const int das08_pgh_gainlist[] = { |
| 8, 0, 10, 2, 12, 4, 14, 6, 1, 3, 5, 7 |
| }; |
| static const int das08_pgl_gainlist[] = { 8, 0, 2, 4, 6, 1, 3, 5, 7 }; |
| static const int das08_pgm_gainlist[] = { 8, 0, 10, 12, 14, 9, 11, 13, 15 }; |
| |
| static const int *const das08_gainlists[] = { |
| NULL, |
| NULL, |
| das08_pgh_gainlist, |
| das08_pgl_gainlist, |
| das08_pgm_gainlist, |
| }; |
| |
| #define TIMEOUT 100000 |
| |
| static int das08_ai_rinsn(struct comedi_device *dev, struct comedi_subdevice *s, |
| struct comedi_insn *insn, unsigned int *data) |
| { |
| const struct das08_board_struct *thisboard = comedi_board(dev); |
| struct das08_private_struct *devpriv = dev->private; |
| int i, n; |
| int chan; |
| int range; |
| int lsb, msb; |
| |
| chan = CR_CHAN(insn->chanspec); |
| range = CR_RANGE(insn->chanspec); |
| |
| /* clear crap */ |
| inb(dev->iobase + DAS08_LSB); |
| inb(dev->iobase + DAS08_MSB); |
| |
| /* set multiplexer */ |
| /* lock to prevent race with digital output */ |
| spin_lock(&dev->spinlock); |
| devpriv->do_mux_bits &= ~DAS08_MUX_MASK; |
| devpriv->do_mux_bits |= DAS08_MUX(chan); |
| outb(devpriv->do_mux_bits, dev->iobase + DAS08_CONTROL); |
| spin_unlock(&dev->spinlock); |
| |
| if (s->range_table->length > 1) { |
| /* set gain/range */ |
| range = CR_RANGE(insn->chanspec); |
| outb(devpriv->pg_gainlist[range], |
| dev->iobase + DAS08AO_GAIN_CONTROL); |
| } |
| |
| for (n = 0; n < insn->n; n++) { |
| /* clear over-range bits for 16-bit boards */ |
| if (thisboard->ai_nbits == 16) |
| if (inb(dev->iobase + DAS08_MSB) & 0x80) |
| dev_info(dev->class_dev, "over-range\n"); |
| |
| /* trigger conversion */ |
| outb_p(0, dev->iobase + DAS08_TRIG_12BIT); |
| |
| for (i = 0; i < TIMEOUT; i++) { |
| if (!(inb(dev->iobase + DAS08_STATUS) & DAS08_EOC)) |
| break; |
| } |
| if (i == TIMEOUT) { |
| dev_err(dev->class_dev, "timeout\n"); |
| return -ETIME; |
| } |
| msb = inb(dev->iobase + DAS08_MSB); |
| lsb = inb(dev->iobase + DAS08_LSB); |
| if (thisboard->ai_encoding == das08_encode12) { |
| data[n] = (lsb >> 4) | (msb << 4); |
| } else if (thisboard->ai_encoding == das08_pcm_encode12) { |
| data[n] = (msb << 8) + lsb; |
| } else if (thisboard->ai_encoding == das08_encode16) { |
| /* FPOS 16-bit boards are sign-magnitude */ |
| if (msb & 0x80) |
| data[n] = (1 << 15) | lsb | ((msb & 0x7f) << 8); |
| else |
| data[n] = (1 << 15) - (lsb | (msb & 0x7f) << 8); |
| } else { |
| comedi_error(dev, "bug! unknown ai encoding"); |
| return -1; |
| } |
| } |
| |
| return n; |
| } |
| |
| static int das08_di_rbits(struct comedi_device *dev, struct comedi_subdevice *s, |
| struct comedi_insn *insn, unsigned int *data) |
| { |
| data[0] = 0; |
| data[1] = DAS08_IP(inb(dev->iobase + DAS08_STATUS)); |
| |
| return insn->n; |
| } |
| |
| static int das08_do_wbits(struct comedi_device *dev, struct comedi_subdevice *s, |
| struct comedi_insn *insn, unsigned int *data) |
| { |
| struct das08_private_struct *devpriv = dev->private; |
| int wbits; |
| |
| /* get current settings of digital output lines */ |
| wbits = (devpriv->do_mux_bits >> 4) & 0xf; |
| /* null bits we are going to set */ |
| wbits &= ~data[0]; |
| /* set new bit values */ |
| wbits |= data[0] & data[1]; |
| /* remember digital output bits */ |
| /* prevent race with setting of analog input mux */ |
| spin_lock(&dev->spinlock); |
| devpriv->do_mux_bits &= ~DAS08_DO_MASK; |
| devpriv->do_mux_bits |= DAS08_OP(wbits); |
| outb(devpriv->do_mux_bits, dev->iobase + DAS08_CONTROL); |
| spin_unlock(&dev->spinlock); |
| |
| data[1] = wbits; |
| |
| return insn->n; |
| } |
| |
| static int das08jr_di_rbits(struct comedi_device *dev, |
| struct comedi_subdevice *s, |
| struct comedi_insn *insn, unsigned int *data) |
| { |
| data[0] = 0; |
| data[1] = inb(dev->iobase + DAS08JR_DIO); |
| |
| return insn->n; |
| } |
| |
| static int das08jr_do_wbits(struct comedi_device *dev, |
| struct comedi_subdevice *s, |
| struct comedi_insn *insn, unsigned int *data) |
| { |
| struct das08_private_struct *devpriv = dev->private; |
| |
| /* null bits we are going to set */ |
| devpriv->do_bits &= ~data[0]; |
| /* set new bit values */ |
| devpriv->do_bits |= data[0] & data[1]; |
| outb(devpriv->do_bits, dev->iobase + DAS08JR_DIO); |
| |
| data[1] = devpriv->do_bits; |
| |
| return insn->n; |
| } |
| |
| static void das08_ao_set_data(struct comedi_device *dev, |
| unsigned int chan, unsigned int data) |
| { |
| const struct das08_board_struct *thisboard = comedi_board(dev); |
| struct das08_private_struct *devpriv = dev->private; |
| unsigned char lsb; |
| unsigned char msb; |
| |
| lsb = data & 0xff; |
| msb = (data >> 8) & 0xff; |
| if (thisboard->is_jr) { |
| outb(lsb, dev->iobase + DAS08JR_AO_LSB(chan)); |
| outb(msb, dev->iobase + DAS08JR_AO_MSB(chan)); |
| /* load DACs */ |
| inb(dev->iobase + DAS08JR_DIO); |
| } else { |
| outb(lsb, dev->iobase + DAS08AO_AO_LSB(chan)); |
| outb(msb, dev->iobase + DAS08AO_AO_MSB(chan)); |
| /* load DACs */ |
| inb(dev->iobase + DAS08AO_AO_UPDATE); |
| } |
| devpriv->ao_readback[chan] = data; |
| } |
| |
| static void das08_ao_initialize(struct comedi_device *dev, |
| struct comedi_subdevice *s) |
| { |
| int n; |
| unsigned int data; |
| |
| data = s->maxdata / 2; /* should be about 0 volts */ |
| for (n = 0; n < s->n_chan; n++) |
| das08_ao_set_data(dev, n, data); |
| } |
| |
| static int das08_ao_winsn(struct comedi_device *dev, |
| struct comedi_subdevice *s, |
| struct comedi_insn *insn, unsigned int *data) |
| { |
| unsigned int n; |
| unsigned int chan; |
| |
| chan = CR_CHAN(insn->chanspec); |
| |
| for (n = 0; n < insn->n; n++) |
| das08_ao_set_data(dev, chan, *data); |
| |
| return n; |
| } |
| |
| static int das08_ao_rinsn(struct comedi_device *dev, |
| struct comedi_subdevice *s, |
| struct comedi_insn *insn, unsigned int *data) |
| { |
| struct das08_private_struct *devpriv = dev->private; |
| unsigned int n; |
| unsigned int chan; |
| |
| chan = CR_CHAN(insn->chanspec); |
| |
| for (n = 0; n < insn->n; n++) |
| data[n] = devpriv->ao_readback[chan]; |
| |
| return n; |
| } |
| |
| static void i8254_initialize(struct comedi_device *dev) |
| { |
| const struct das08_board_struct *thisboard = comedi_board(dev); |
| unsigned long i8254_iobase = dev->iobase + thisboard->i8254_offset; |
| unsigned int mode = I8254_MODE0 | I8254_BINARY; |
| int i; |
| |
| for (i = 0; i < 3; ++i) |
| i8254_set_mode(i8254_iobase, 0, i, mode); |
| } |
| |
| static int das08_counter_read(struct comedi_device *dev, |
| struct comedi_subdevice *s, |
| struct comedi_insn *insn, unsigned int *data) |
| { |
| const struct das08_board_struct *thisboard = comedi_board(dev); |
| unsigned long i8254_iobase = dev->iobase + thisboard->i8254_offset; |
| int chan = insn->chanspec; |
| |
| data[0] = i8254_read(i8254_iobase, 0, chan); |
| return 1; |
| } |
| |
| static int das08_counter_write(struct comedi_device *dev, |
| struct comedi_subdevice *s, |
| struct comedi_insn *insn, unsigned int *data) |
| { |
| const struct das08_board_struct *thisboard = comedi_board(dev); |
| unsigned long i8254_iobase = dev->iobase + thisboard->i8254_offset; |
| int chan = insn->chanspec; |
| |
| i8254_write(i8254_iobase, 0, chan, data[0]); |
| return 1; |
| } |
| |
| static int das08_counter_config(struct comedi_device *dev, |
| struct comedi_subdevice *s, |
| struct comedi_insn *insn, unsigned int *data) |
| { |
| const struct das08_board_struct *thisboard = comedi_board(dev); |
| unsigned long i8254_iobase = dev->iobase + thisboard->i8254_offset; |
| int chan = insn->chanspec; |
| |
| switch (data[0]) { |
| case INSN_CONFIG_SET_COUNTER_MODE: |
| i8254_set_mode(i8254_iobase, 0, chan, data[1]); |
| break; |
| case INSN_CONFIG_8254_READ_STATUS: |
| data[1] = i8254_status(i8254_iobase, 0, chan); |
| break; |
| default: |
| return -EINVAL; |
| break; |
| } |
| return 2; |
| } |
| |
| int das08_common_attach(struct comedi_device *dev, unsigned long iobase) |
| { |
| const struct das08_board_struct *thisboard = comedi_board(dev); |
| struct das08_private_struct *devpriv = dev->private; |
| struct comedi_subdevice *s; |
| int ret; |
| |
| dev->iobase = iobase; |
| |
| dev->board_name = thisboard->name; |
| |
| ret = comedi_alloc_subdevices(dev, 6); |
| if (ret) |
| return ret; |
| |
| s = &dev->subdevices[0]; |
| /* ai */ |
| if (thisboard->ai_nbits) { |
| s->type = COMEDI_SUBD_AI; |
| /* XXX some boards actually have differential |
| * inputs instead of single ended. |
| * The driver does nothing with arefs though, |
| * so it's no big deal. |
| */ |
| s->subdev_flags = SDF_READABLE | SDF_GROUND; |
| s->n_chan = 8; |
| s->maxdata = (1 << thisboard->ai_nbits) - 1; |
| s->range_table = das08_ai_lranges[thisboard->ai_pg]; |
| s->insn_read = das08_ai_rinsn; |
| devpriv->pg_gainlist = das08_gainlists[thisboard->ai_pg]; |
| } else { |
| s->type = COMEDI_SUBD_UNUSED; |
| } |
| |
| s = &dev->subdevices[1]; |
| /* ao */ |
| if (thisboard->ao_nbits) { |
| s->type = COMEDI_SUBD_AO; |
| s->subdev_flags = SDF_WRITABLE; |
| s->n_chan = 2; |
| s->maxdata = (1 << thisboard->ao_nbits) - 1; |
| s->range_table = &range_bipolar5; |
| s->insn_write = das08_ao_winsn; |
| s->insn_read = das08_ao_rinsn; |
| das08_ao_initialize(dev, s); |
| } else { |
| s->type = COMEDI_SUBD_UNUSED; |
| } |
| |
| s = &dev->subdevices[2]; |
| /* di */ |
| if (thisboard->di_nchan) { |
| s->type = COMEDI_SUBD_DI; |
| s->subdev_flags = SDF_READABLE; |
| s->n_chan = thisboard->di_nchan; |
| s->maxdata = 1; |
| s->range_table = &range_digital; |
| s->insn_bits = |
| thisboard->is_jr ? das08jr_di_rbits : das08_di_rbits; |
| } else { |
| s->type = COMEDI_SUBD_UNUSED; |
| } |
| |
| s = &dev->subdevices[3]; |
| /* do */ |
| if (thisboard->do_nchan) { |
| s->type = COMEDI_SUBD_DO; |
| s->subdev_flags = SDF_WRITABLE | SDF_READABLE; |
| s->n_chan = thisboard->do_nchan; |
| s->maxdata = 1; |
| s->range_table = &range_digital; |
| s->insn_bits = |
| thisboard->is_jr ? das08jr_do_wbits : das08_do_wbits; |
| } else { |
| s->type = COMEDI_SUBD_UNUSED; |
| } |
| |
| s = &dev->subdevices[4]; |
| /* 8255 */ |
| if (thisboard->i8255_offset != 0) { |
| subdev_8255_init(dev, s, NULL, (unsigned long)(dev->iobase + |
| thisboard-> |
| i8255_offset)); |
| } else { |
| s->type = COMEDI_SUBD_UNUSED; |
| } |
| |
| s = &dev->subdevices[5]; |
| /* 8254 */ |
| if (thisboard->i8254_offset != 0) { |
| s->type = COMEDI_SUBD_COUNTER; |
| s->subdev_flags = SDF_WRITABLE | SDF_READABLE; |
| s->n_chan = 3; |
| s->maxdata = 0xFFFF; |
| s->insn_read = das08_counter_read; |
| s->insn_write = das08_counter_write; |
| s->insn_config = das08_counter_config; |
| i8254_initialize(dev); |
| } else { |
| s->type = COMEDI_SUBD_UNUSED; |
| } |
| |
| return 0; |
| } |
| EXPORT_SYMBOL_GPL(das08_common_attach); |
| |
| void das08_common_detach(struct comedi_device *dev) |
| { |
| comedi_spriv_free(dev, 4); |
| } |
| EXPORT_SYMBOL_GPL(das08_common_detach); |
| |
| static int __init das08_init(void) |
| { |
| return 0; |
| } |
| module_init(das08_init); |
| |
| static void __exit das08_exit(void) |
| { |
| } |
| module_exit(das08_exit); |
| |
| MODULE_AUTHOR("Comedi http://www.comedi.org"); |
| MODULE_DESCRIPTION("Comedi low-level driver"); |
| MODULE_LICENSE("GPL"); |