/* comedi/drivers/das08.c DAS08 driver COMEDI - Linux Control and Measurement Device Interface Copyright (C) 2000 David A. Schleef Copyright (C) 2001,2002,2003 Frank Mori Hess Copyright (C) 2004 Salvador E. Tropea 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 Author: Warren Jasper, ds, Frank Hess Devices: [Keithley Metrabyte] DAS08 (isa-das08), [ComputerBoards] DAS08 (isa-das08), DAS08-PGM (das08-pgm), DAS08-PGH (das08-pgh), DAS08-PGL (das08-pgl), DAS08-AOH (das08-aoh), DAS08-AOL (das08-aol), DAS08-AOM (das08-aom), DAS08/JR-AO (das08/jr-ao), DAS08/JR-16-AO (das08jr-16-ao), PCI-DAS08 (das08), PC104-DAS08 (pc104-das08), DAS08/JR/16 (das08jr/16) Status: works This is a rewrite of the das08 and das08jr drivers. Options (for ISA cards): [0] - base io address Options (for pci-das08): [0] - bus (optional) [1] = slot (optional) The das08 driver doesn't support asynchronous commands, since the cheap das08 hardware doesn't really support them. The comedi_rt_timer driver can be used to emulate commands for this driver. */ #include "../comedidev.h" #include #include "comedi_pci.h" #include "8255.h" #include "das08.h" #define DRV_NAME "das08" #define PCI_VENDOR_ID_COMPUTERBOARDS 0x1307 #define PCI_DEVICE_ID_PCIDAS08 0x29 #define PCIDAS08_SIZE 0x54 /* pci configuration registers */ #define INTCSR 0x4c #define INTR1_ENABLE 0x1 #define INTR1_HIGH_POLARITY 0x2 #define PCI_INTR_ENABLE 0x40 #define INTR1_EDGE_TRIG 0x100 /* requires high polarity */ #define CNTRL 0x50 #define CNTRL_DIR 0x2 #define CNTRL_INTR 0x4 /* 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 int das08_ai_rinsn(struct comedi_device *dev, struct comedi_subdevice *s, struct comedi_insn *insn, unsigned int *data); static int das08_di_rbits(struct comedi_device *dev, struct comedi_subdevice *s, struct comedi_insn *insn, unsigned int *data); static int das08_do_wbits(struct comedi_device *dev, struct comedi_subdevice *s, struct comedi_insn *insn, unsigned int *data); static int das08jr_di_rbits(struct comedi_device *dev, struct comedi_subdevice *s, struct comedi_insn *insn, unsigned int *data); static int das08jr_do_wbits(struct comedi_device *dev, struct comedi_subdevice *s, struct comedi_insn *insn, unsigned int *data); static int das08jr_ao_winsn(struct comedi_device *dev, struct comedi_subdevice *s, struct comedi_insn *insn, unsigned int *data); static int das08ao_ao_winsn(struct comedi_device *dev, struct comedi_subdevice *s, struct comedi_insn *insn, unsigned int *data); static void i8254_set_mode_low(unsigned int base, int channel, unsigned int mode); 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, }; static const struct das08_board_struct das08_boards[] = { { .name = "isa-das08", /* cio-das08.pdf */ .bustype = isa, .ai = das08_ai_rinsn, .ai_nbits = 12, .ai_pg = das08_pg_none, .ai_encoding = das08_encode12, .ao = NULL, .ao_nbits = 12, .di = das08_di_rbits, .do_ = das08_do_wbits, .do_nchan = 4, .i8255_offset = 8, .i8254_offset = 4, .iosize = 16, /* unchecked */ }, { .name = "das08-pgm", /* cio-das08pgx.pdf */ .bustype = isa, .ai = das08_ai_rinsn, .ai_nbits = 12, .ai_pg = das08_pgm, .ai_encoding = das08_encode12, .ao = NULL, .di = das08_di_rbits, .do_ = das08_do_wbits, .do_nchan = 4, .i8255_offset = 0, .i8254_offset = 0x04, .iosize = 16, /* unchecked */ }, { .name = "das08-pgh", /* cio-das08pgx.pdf */ .bustype = isa, .ai = das08_ai_rinsn, .ai_nbits = 12, .ai_pg = das08_pgh, .ai_encoding = das08_encode12, .ao = NULL, .di = das08_di_rbits, .do_ = das08_do_wbits, .do_nchan = 4, .i8255_offset = 0, .i8254_offset = 0x04, .iosize = 16, /* unchecked */ }, { .name = "das08-pgl", /* cio-das08pgx.pdf */ .bustype = isa, .ai = das08_ai_rinsn, .ai_nbits = 12, .ai_pg = das08_pgl, .ai_encoding = das08_encode12, .ao = NULL, .di = das08_di_rbits, .do_ = das08_do_wbits, .do_nchan = 4, .i8255_offset = 0, .i8254_offset = 0x04, .iosize = 16, /* unchecked */ }, { .name = "das08-aoh", /* cio-das08_aox.pdf */ .bustype = isa, .ai = das08_ai_rinsn, .ai_nbits = 12, .ai_pg = das08_pgh, .ai_encoding = das08_encode12, .ao = das08ao_ao_winsn, /* 8 */ .ao_nbits = 12, .di = das08_di_rbits, .do_ = das08_do_wbits, .do_nchan = 4, .i8255_offset = 0x0c, .i8254_offset = 0x04, .iosize = 16, /* unchecked */ }, { .name = "das08-aol", /* cio-das08_aox.pdf */ .bustype = isa, .ai = das08_ai_rinsn, .ai_nbits = 12, .ai_pg = das08_pgl, .ai_encoding = das08_encode12, .ao = das08ao_ao_winsn, /* 8 */ .ao_nbits = 12, .di = das08_di_rbits, .do_ = das08_do_wbits, .do_nchan = 4, .i8255_offset = 0x0c, .i8254_offset = 0x04, .iosize = 16, /* unchecked */ }, { .name = "das08-aom", /* cio-das08_aox.pdf */ .bustype = isa, .ai = das08_ai_rinsn, .ai_nbits = 12, .ai_pg = das08_pgm, .ai_encoding = das08_encode12, .ao = das08ao_ao_winsn, /* 8 */ .ao_nbits = 12, .di = das08_di_rbits, .do_ = das08_do_wbits, .do_nchan = 4, .i8255_offset = 0x0c, .i8254_offset = 0x04, .iosize = 16, /* unchecked */ }, { .name = "das08/jr-ao", /* cio-das08-jr-ao.pdf */ .bustype = isa, .ai = das08_ai_rinsn, .ai_nbits = 12, .ai_pg = das08_pg_none, .ai_encoding = das08_encode12, .ao = das08jr_ao_winsn, .ao_nbits = 12, .di = das08jr_di_rbits, .do_ = das08jr_do_wbits, .do_nchan = 8, .i8255_offset = 0, .i8254_offset = 0, .iosize = 16, /* unchecked */ }, { .name = "das08jr-16-ao", /* cio-das08jr-16-ao.pdf */ .bustype = isa, .ai = das08_ai_rinsn, .ai_nbits = 16, .ai_pg = das08_pg_none, .ai_encoding = das08_encode12, .ao = das08jr_ao_winsn, .ao_nbits = 16, .di = das08jr_di_rbits, .do_ = das08jr_do_wbits, .do_nchan = 8, .i8255_offset = 0, .i8254_offset = 0x04, .iosize = 16, /* unchecked */ }, #ifdef CONFIG_COMEDI_PCI { .name = "das08", /* pci-das08 */ .id = PCI_DEVICE_ID_PCIDAS08, .bustype = pci, .ai = das08_ai_rinsn, .ai_nbits = 12, .ai_pg = das08_bipolar5, .ai_encoding = das08_encode12, .ao = NULL, .ao_nbits = 0, .di = das08_di_rbits, .do_ = das08_do_wbits, .do_nchan = 4, .i8255_offset = 0, .i8254_offset = 4, .iosize = 8, }, #endif { .name = "pc104-das08", .bustype = pc104, .ai = das08_ai_rinsn, .ai_nbits = 12, .ai_pg = das08_pg_none, .ai_encoding = das08_encode12, .ao = NULL, .ao_nbits = 0, .di = das08_di_rbits, .do_ = das08_do_wbits, .do_nchan = 4, .i8255_offset = 0, .i8254_offset = 4, .iosize = 16, /* unchecked */ }, #if 0 { .name = "das08/f", }, { .name = "das08jr", }, #endif { .name = "das08jr/16", .bustype = isa, .ai = das08_ai_rinsn, .ai_nbits = 16, .ai_pg = das08_pg_none, .ai_encoding = das08_encode16, .ao = NULL, .ao_nbits = 0, .di = das08jr_di_rbits, .do_ = das08jr_do_wbits, .do_nchan = 8, .i8255_offset = 0, .i8254_offset = 0, .iosize = 16, /* unchecked */ }, #if 0 { .name = "das48-pga", /* cio-das48-pga.pdf */ }, { .name = "das08-pga-g2", /* a KM board */ }, #endif }; #ifdef CONFIG_COMEDI_PCMCIA struct das08_board_struct das08_cs_boards[NUM_DAS08_CS_BOARDS] = { { .name = "pcm-das08", .id = 0x0, /* XXX */ .bustype = pcmcia, .ai = das08_ai_rinsn, .ai_nbits = 12, .ai_pg = das08_bipolar5, .ai_encoding = das08_pcm_encode12, .ao = NULL, .ao_nbits = 0, .di = das08_di_rbits, .do_ = das08_do_wbits, .do_nchan = 3, .i8255_offset = 0, .i8254_offset = 0, .iosize = 16, }, /* duplicate so driver name can be used also */ { .name = "das08_cs", .id = 0x0, /* XXX */ .bustype = pcmcia, .ai = das08_ai_rinsn, .ai_nbits = 12, .ai_pg = das08_bipolar5, .ai_encoding = das08_pcm_encode12, .ao = NULL, .ao_nbits = 0, .di = das08_di_rbits, .do_ = das08_do_wbits, .do_nchan = 3, .i8255_offset = 0, .i8254_offset = 0, .iosize = 16, }, }; #endif #ifdef CONFIG_COMEDI_PCI static DEFINE_PCI_DEVICE_TABLE(das08_pci_table) = { { PCI_VENDOR_ID_COMPUTERBOARDS, PCI_DEVICE_ID_PCIDAS08, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, { 0} }; MODULE_DEVICE_TABLE(pci, das08_pci_table); #endif #define devpriv ((struct das08_private_struct *)dev->private) #define thisboard ((const struct das08_board_struct *)dev->board_ptr) #define TIMEOUT 100000 static int das08_ai_rinsn(struct comedi_device *dev, struct comedi_subdevice *s, struct comedi_insn *insn, unsigned int *data) { 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 */ spin_lock(&dev->spinlock); /* lock to prevent race with digital output */ 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) printk("das08: 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) { printk("das08: 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 2; } static int das08_do_wbits(struct comedi_device *dev, struct comedi_subdevice *s, struct comedi_insn *insn, unsigned int *data) { 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 */ spin_lock(&dev->spinlock); /* prevent race with setting of analog input mux */ 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 2; } 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 2; } static int das08jr_do_wbits(struct comedi_device *dev, struct comedi_subdevice *s, struct comedi_insn *insn, unsigned int *data) { /* 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 2; } static int das08jr_ao_winsn(struct comedi_device *dev, struct comedi_subdevice *s, struct comedi_insn *insn, unsigned int *data) { int n; int lsb, msb; int chan; lsb = data[0] & 0xff; msb = (data[0] >> 8) & 0xf; chan = CR_CHAN(insn->chanspec); for (n = 0; n < insn->n; n++) { #if 0 outb(lsb, dev->iobase + devpriv->ao_offset_lsb[chan]); outb(msb, dev->iobase + devpriv->ao_offset_msb[chan]); #else outb(lsb, dev->iobase + DAS08JR_AO_LSB(chan)); outb(msb, dev->iobase + DAS08JR_AO_MSB(chan)); #endif /* load DACs */ inb(dev->iobase + DAS08JR_DIO); } return n; } /* * * The -aox boards have the DACs at a different offset and use * a different method to force an update. * */ static int das08ao_ao_winsn(struct comedi_device *dev, struct comedi_subdevice *s, struct comedi_insn *insn, unsigned int *data) { int n; int lsb, msb; int chan; lsb = data[0] & 0xff; msb = (data[0] >> 8) & 0xf; chan = CR_CHAN(insn->chanspec); for (n = 0; n < insn->n; n++) { #if 0 outb(lsb, dev->iobase + devpriv->ao_offset_lsb[chan]); outb(msb, dev->iobase + devpriv->ao_offset_msb[chan]); #else outb(lsb, dev->iobase + DAS08AO_AO_LSB(chan)); outb(msb, dev->iobase + DAS08AO_AO_MSB(chan)); #endif /* load DACs */ inb(dev->iobase + DAS08AO_AO_UPDATE); } return n; } static unsigned int i8254_read_channel_low(unsigned int base, int chan) { unsigned int msb, lsb; /* The following instructions must be in order. We must avoid other process reading the counter's value in the middle. The spin_lock isn't needed since ioctl calls grab the big kernel lock automatically */ /*spin_lock(sp); */ outb(chan << 6, base + I8254_CTRL); base += chan; lsb = inb(base); msb = inb(base); /*spin_unlock(sp); */ return lsb | (msb << 8); } static void i8254_write_channel_low(unsigned int base, int chan, unsigned int value) { unsigned int msb, lsb; lsb = value & 0xFF; msb = value >> 8; /* write lsb, then msb */ base += chan; /* See comments in i8254_read_channel_low */ /*spin_lock(sp); */ outb(lsb, base); outb(msb, base); /*spin_unlock(sp); */ } static unsigned int i8254_read_channel(struct i8254_struct *st, int channel) { int chan = st->logic2phys[channel]; return i8254_read_channel_low(st->iobase, chan); } static void i8254_write_channel(struct i8254_struct *st, int channel, unsigned int value) { int chan = st->logic2phys[channel]; i8254_write_channel_low(st->iobase, chan, value); } static void i8254_initialize(struct i8254_struct *st) { int i; for (i = 0; i < 3; ++i) i8254_set_mode_low(st->iobase, i, st->mode[i]); } static void i8254_set_mode_low(unsigned int base, int channel, unsigned int mode) { outb((channel << 6) | 0x30 | (mode & 0x0F), base + I8254_CTRL); } static void i8254_set_mode(struct i8254_struct *st, int channel, unsigned int mode) { int chan = st->logic2phys[channel]; st->mode[chan] = mode; return i8254_set_mode_low(st->iobase, chan, mode); } static unsigned int i8254_read_status_low(unsigned int base, int channel) { outb(0xE0 | (2 << channel), base + I8254_CTRL); return inb(base + channel); } static unsigned int i8254_read_status(struct i8254_struct *st, int channel) { int chan = st->logic2phys[channel]; return i8254_read_status_low(st->iobase, chan); } static int das08_counter_read(struct comedi_device *dev, struct comedi_subdevice *s, struct comedi_insn *insn, unsigned int *data) { int chan = insn->chanspec; /* printk("Reading counter channel %d ",chan); */ data[0] = i8254_read_channel(&devpriv->i8254, chan); /* printk("=> 0x%08X\n",data[0]); */ return 1; } static int das08_counter_write(struct comedi_device *dev, struct comedi_subdevice *s, struct comedi_insn *insn, unsigned int *data) { int chan = insn->chanspec; /* printk("Writing counter channel %d with 0x%04X\n",chan,data[0]); */ i8254_write_channel(&devpriv->i8254, 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) { int chan = insn->chanspec; if (insn->n != 2) return -EINVAL; switch (data[0]) { case INSN_CONFIG_SET_COUNTER_MODE: i8254_set_mode(&devpriv->i8254, chan, data[1]); break; case INSN_CONFIG_8254_READ_STATUS: data[1] = i8254_read_status(&devpriv->i8254, chan); break; default: return -EINVAL; break; } return 2; } static int das08_attach(struct comedi_device *dev, struct comedi_devconfig *it); static struct comedi_driver driver_das08 = { .driver_name = DRV_NAME, .module = THIS_MODULE, .attach = das08_attach, .detach = das08_common_detach, .board_name = &das08_boards[0].name, .num_names = sizeof(das08_boards) / sizeof(struct das08_board_struct), .offset = sizeof(struct das08_board_struct), }; int das08_common_attach(struct comedi_device *dev, unsigned long iobase) { struct comedi_subdevice *s; int ret; /* allocate ioports for non-pcmcia, non-pci boards */ if ((thisboard->bustype != pcmcia) && (thisboard->bustype != pci)) { printk(" iobase 0x%lx\n", iobase); if (!request_region(iobase, thisboard->iosize, DRV_NAME)) { printk(" I/O port conflict\n"); return -EIO; } } dev->iobase = iobase; dev->board_name = thisboard->name; ret = alloc_subdevices(dev, 6); if (ret < 0) return ret; s = dev->subdevices + 0; /* ai */ if (thisboard->ai) { 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 = thisboard->ai; devpriv->pg_gainlist = das08_gainlists[thisboard->ai_pg]; } else { s->type = COMEDI_SUBD_UNUSED; } s = dev->subdevices + 1; /* ao */ if (thisboard->ao) { s->type = COMEDI_SUBD_AO; /* XXX lacks read-back insn */ s->subdev_flags = SDF_WRITABLE; s->n_chan = 2; s->maxdata = (1 << thisboard->ao_nbits) - 1; s->range_table = &range_bipolar5; s->insn_write = thisboard->ao; } else { s->type = COMEDI_SUBD_UNUSED; } s = dev->subdevices + 2; /* di */ if (thisboard->di) { s->type = COMEDI_SUBD_DI; s->subdev_flags = SDF_READABLE; s->n_chan = (thisboard->di == das08_di_rbits) ? 3 : 8; s->maxdata = 1; s->range_table = &range_digital; s->insn_bits = thisboard->di; } else { s->type = COMEDI_SUBD_UNUSED; } s = dev->subdevices + 3; /* do */ if (thisboard->do_) { 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->do_; } 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; /* Set-up the 8254 structure */ devpriv->i8254.channels = 3; devpriv->i8254.logic2phys[0] = 0; devpriv->i8254.logic2phys[1] = 1; devpriv->i8254.logic2phys[2] = 2; devpriv->i8254.iobase = iobase + thisboard->i8254_offset; devpriv->i8254.mode[0] = devpriv->i8254.mode[1] = devpriv->i8254.mode[2] = I8254_MODE0 | I8254_BINARY; i8254_initialize(&devpriv->i8254); } else { s->type = COMEDI_SUBD_UNUSED; } return 0; } static int das08_attach(struct comedi_device *dev, struct comedi_devconfig *it) { int ret; unsigned long iobase; #ifdef CONFIG_COMEDI_PCI unsigned long pci_iobase = 0; struct pci_dev *pdev; #endif ret = alloc_private(dev, sizeof(struct das08_private_struct)); if (ret < 0) return ret; printk("comedi%d: das08: ", dev->minor); /* deal with a pci board */ if (thisboard->bustype == pci) { #ifdef CONFIG_COMEDI_PCI if (it->options[0] || it->options[1]) { printk("bus %i slot %i ", it->options[0], it->options[1]); } printk("\n"); /* find card */ for (pdev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, NULL); pdev != NULL; pdev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, pdev)) { if (pdev->vendor == PCI_VENDOR_ID_COMPUTERBOARDS && pdev->device == PCI_DEVICE_ID_PCIDAS08) { if (it->options[0] || it->options[1]) { if (pdev->bus->number == it->options[0] && PCI_SLOT(pdev->devfn) == it->options[1]) { break; } } else { break; } } } if (!pdev) { printk("No pci das08 cards found\n"); return -EIO; } devpriv->pdev = pdev; /* enable PCI device and reserve I/O spaces */ if (comedi_pci_enable(pdev, DRV_NAME)) { printk (" Error enabling PCI device and requesting regions\n"); return -EIO; } /* read base addresses */ pci_iobase = pci_resource_start(pdev, 1); iobase = pci_resource_start(pdev, 2); printk("pcibase 0x%lx iobase 0x%lx\n", pci_iobase, iobase); devpriv->pci_iobase = pci_iobase; #if 0 /* We could enable to pci-das08's interrupt here to make it possible * to do timed input in this driver, but there is little point since * conversions would have to be started by the interrupt handler * so you might as well use comedi_rt_timer to emulate commands */ /* set source of interrupt trigger to counter2 output */ outb(CNTRL_INTR | CNTRL_DIR, pci_iobase + CNTRL); /* Enable local interrupt 1 and pci interrupt */ outw(INTR1_ENABLE | PCI_INTR_ENABLE, pci_iobase + INTCSR); #endif #else /* CONFIG_COMEDI_PCI */ printk("this driver has not been built with PCI support.\n"); return -EINVAL; #endif /* CONFIG_COMEDI_PCI */ } else { iobase = it->options[0]; } printk("\n"); return das08_common_attach(dev, iobase); } int das08_common_detach(struct comedi_device *dev) { printk(KERN_INFO "comedi%d: das08: remove\n", dev->minor); if (dev->subdevices) subdev_8255_cleanup(dev, dev->subdevices + 4); /* deallocate ioports for non-pcmcia, non-pci boards */ if ((thisboard->bustype != pcmcia) && (thisboard->bustype != pci)) { if (dev->iobase) release_region(dev->iobase, thisboard->iosize); } #ifdef CONFIG_COMEDI_PCI if (devpriv) { if (devpriv->pdev) { if (devpriv->pci_iobase) { comedi_pci_disable(devpriv->pdev); } pci_dev_put(devpriv->pdev); } } #endif return 0; } #ifdef CONFIG_COMEDI_PCI COMEDI_PCI_INITCLEANUP(driver_das08, das08_pci_table); #else COMEDI_INITCLEANUP(driver_das08); #endif EXPORT_SYMBOL_GPL(das08_common_attach); EXPORT_SYMBOL_GPL(das08_common_detach); #ifdef CONFIG_COMEDI_PCMCIA EXPORT_SYMBOL_GPL(das08_cs_boards); #endif