/* comedi/drivers/das16cs.c Driver for Computer Boards PC-CARD DAS16/16. COMEDI - Linux Control and Measurement Device Interface Copyright (C) 2000, 2001, 2002 David A. Schleef 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. PCMCIA support code for this driver is adapted from the dummy_cs.c driver of the Linux PCMCIA Card Services package. The initial developer of the original code is David A. Hinds . Portions created by David A. Hinds are Copyright (C) 1999 David A. Hinds. All Rights Reserved. */ /* Driver: cb_das16_cs Description: Computer Boards PC-CARD DAS16/16 Devices: [ComputerBoards] PC-CARD DAS16/16 (cb_das16_cs), PC-CARD DAS16/16-AO Author: ds Updated: Mon, 04 Nov 2002 20:04:21 -0800 Status: experimental */ #include #include #include #include "../comedi_pcmcia.h" #include "comedi_fc.h" #include "8253.h" #define DAS16CS_ADC_DATA 0 #define DAS16CS_DIO_MUX 2 #define DAS16CS_MISC1 4 #define DAS16CS_MISC2 6 #define DAS16CS_CTR0 8 #define DAS16CS_CTR1 10 #define DAS16CS_CTR2 12 #define DAS16CS_CTR_CONTROL 14 #define DAS16CS_DIO 16 struct das16cs_board { const char *name; int device_id; int n_ao_chans; }; static const struct das16cs_board das16cs_boards[] = { { .name = "PC-CARD DAS16/16-AO", .device_id = 0x0039, .n_ao_chans = 2, }, { .name = "PCM-DAS16s/16", .device_id = 0x4009, .n_ao_chans = 0, }, { .name = "PC-CARD DAS16/16", .device_id = 0x0000, /* unknown */ .n_ao_chans = 0, }, }; struct das16cs_private { unsigned short status1; unsigned short status2; }; static const struct comedi_lrange das16cs_ai_range = { 4, { BIP_RANGE(10), BIP_RANGE(5), BIP_RANGE(2.5), BIP_RANGE(1.25), } }; static int das16cs_ai_eoc(struct comedi_device *dev, struct comedi_subdevice *s, struct comedi_insn *insn, unsigned long context) { unsigned int status; status = inw(dev->iobase + DAS16CS_MISC1); if (status & 0x0080) return 0; return -EBUSY; } static int das16cs_ai_rinsn(struct comedi_device *dev, struct comedi_subdevice *s, struct comedi_insn *insn, unsigned int *data) { struct das16cs_private *devpriv = dev->private; int chan = CR_CHAN(insn->chanspec); int range = CR_RANGE(insn->chanspec); int aref = CR_AREF(insn->chanspec); int ret; int i; outw(chan, dev->iobase + DAS16CS_DIO_MUX); devpriv->status1 &= ~0xf320; devpriv->status1 |= (aref == AREF_DIFF) ? 0 : 0x0020; outw(devpriv->status1, dev->iobase + DAS16CS_MISC1); devpriv->status2 &= ~0xff00; switch (range) { case 0: devpriv->status2 |= 0x800; break; case 1: devpriv->status2 |= 0x000; break; case 2: devpriv->status2 |= 0x100; break; case 3: devpriv->status2 |= 0x200; break; } outw(devpriv->status2, dev->iobase + DAS16CS_MISC2); for (i = 0; i < insn->n; i++) { outw(0, dev->iobase + DAS16CS_ADC_DATA); ret = comedi_timeout(dev, s, insn, das16cs_ai_eoc, 0); if (ret) return ret; data[i] = inw(dev->iobase + DAS16CS_ADC_DATA); } return i; } static int das16cs_ao_insn_write(struct comedi_device *dev, struct comedi_subdevice *s, struct comedi_insn *insn, unsigned int *data) { struct das16cs_private *devpriv = dev->private; unsigned int chan = CR_CHAN(insn->chanspec); unsigned int val = s->readback[chan]; unsigned short status1; int bit; int i; for (i = 0; i < insn->n; i++) { val = data[i]; outw(devpriv->status1, dev->iobase + DAS16CS_MISC1); udelay(1); status1 = devpriv->status1 & ~0xf; if (chan) status1 |= 0x0001; else status1 |= 0x0008; outw(status1, dev->iobase + DAS16CS_MISC1); udelay(1); for (bit = 15; bit >= 0; bit--) { int b = (val >> bit) & 0x1; b <<= 1; outw(status1 | b | 0x0000, dev->iobase + DAS16CS_MISC1); udelay(1); outw(status1 | b | 0x0004, dev->iobase + DAS16CS_MISC1); udelay(1); } /* * Make both DAC0CS and DAC1CS high to load * the new data and update analog the output */ outw(status1 | 0x9, dev->iobase + DAS16CS_MISC1); } s->readback[chan] = val; return insn->n; } static int das16cs_dio_insn_bits(struct comedi_device *dev, struct comedi_subdevice *s, struct comedi_insn *insn, unsigned int *data) { if (comedi_dio_update_state(s, data)) outw(s->state, dev->iobase + DAS16CS_DIO); data[1] = inw(dev->iobase + DAS16CS_DIO); return insn->n; } static int das16cs_dio_insn_config(struct comedi_device *dev, struct comedi_subdevice *s, struct comedi_insn *insn, unsigned int *data) { struct das16cs_private *devpriv = dev->private; unsigned int chan = CR_CHAN(insn->chanspec); unsigned int mask; int ret; if (chan < 4) mask = 0x0f; else mask = 0xf0; ret = comedi_dio_insn_config(dev, s, insn, data, mask); if (ret) return ret; devpriv->status2 &= ~0x00c0; devpriv->status2 |= (s->io_bits & 0xf0) ? 0x0080 : 0; devpriv->status2 |= (s->io_bits & 0x0f) ? 0x0040 : 0; outw(devpriv->status2, dev->iobase + DAS16CS_MISC2); return insn->n; } static const void *das16cs_find_boardinfo(struct comedi_device *dev, struct pcmcia_device *link) { const struct das16cs_board *board; int i; for (i = 0; i < ARRAY_SIZE(das16cs_boards); i++) { board = &das16cs_boards[i]; if (board->device_id == link->card_id) return board; } return NULL; } static int das16cs_auto_attach(struct comedi_device *dev, unsigned long context) { struct pcmcia_device *link = comedi_to_pcmcia_dev(dev); const struct das16cs_board *board; struct das16cs_private *devpriv; struct comedi_subdevice *s; int ret; board = das16cs_find_boardinfo(dev, link); if (!board) return -ENODEV; dev->board_ptr = board; dev->board_name = board->name; link->config_flags |= CONF_AUTO_SET_IO | CONF_ENABLE_IRQ; ret = comedi_pcmcia_enable(dev, NULL); if (ret) return ret; dev->iobase = link->resource[0]->start; link->priv = dev; devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv)); if (!devpriv) return -ENOMEM; ret = comedi_alloc_subdevices(dev, 3); if (ret) return ret; s = &dev->subdevices[0]; /* analog input subdevice */ s->type = COMEDI_SUBD_AI; s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_DIFF | SDF_CMD_READ; s->n_chan = 16; s->maxdata = 0xffff; s->range_table = &das16cs_ai_range; s->len_chanlist = 16; s->insn_read = das16cs_ai_rinsn; s = &dev->subdevices[1]; /* analog output subdevice */ if (board->n_ao_chans) { s->type = COMEDI_SUBD_AO; s->subdev_flags = SDF_WRITABLE; s->n_chan = board->n_ao_chans; s->maxdata = 0xffff; s->range_table = &range_bipolar10; s->insn_write = &das16cs_ao_insn_write; ret = comedi_alloc_subdev_readback(s); if (ret) return ret; } else { s->type = COMEDI_SUBD_UNUSED; } s = &dev->subdevices[2]; /* digital i/o subdevice */ s->type = COMEDI_SUBD_DIO; s->subdev_flags = SDF_READABLE | SDF_WRITABLE; s->n_chan = 8; s->maxdata = 1; s->range_table = &range_digital; s->insn_bits = das16cs_dio_insn_bits; s->insn_config = das16cs_dio_insn_config; return 0; } static struct comedi_driver driver_das16cs = { .driver_name = "cb_das16_cs", .module = THIS_MODULE, .auto_attach = das16cs_auto_attach, .detach = comedi_pcmcia_disable, }; static int das16cs_pcmcia_attach(struct pcmcia_device *link) { return comedi_pcmcia_auto_config(link, &driver_das16cs); } static const struct pcmcia_device_id das16cs_id_table[] = { PCMCIA_DEVICE_MANF_CARD(0x01c5, 0x0039), PCMCIA_DEVICE_MANF_CARD(0x01c5, 0x4009), PCMCIA_DEVICE_NULL }; MODULE_DEVICE_TABLE(pcmcia, das16cs_id_table); static struct pcmcia_driver das16cs_driver = { .name = "cb_das16_cs", .owner = THIS_MODULE, .id_table = das16cs_id_table, .probe = das16cs_pcmcia_attach, .remove = comedi_pcmcia_auto_unconfig, }; module_comedi_pcmcia_driver(driver_das16cs, das16cs_driver); MODULE_AUTHOR("David A. Schleef "); MODULE_DESCRIPTION("Comedi driver for Computer Boards PC-CARD DAS16/16"); MODULE_LICENSE("GPL");