Version:  2.0.40 2.2.26 2.4.37 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17

Linux/drivers/staging/comedi/drivers/cb_pcimdas.c

  1 /*
  2     comedi/drivers/cb_pcimdas.c
  3     Comedi driver for Computer Boards PCIM-DAS1602/16
  4 
  5     COMEDI - Linux Control and Measurement Device Interface
  6     Copyright (C) 2000 David A. Schleef <ds@schleef.org>
  7 
  8     This program is free software; you can redistribute it and/or modify
  9     it under the terms of the GNU General Public License as published by
 10     the Free Software Foundation; either version 2 of the License, or
 11     (at your option) any later version.
 12 
 13     This program is distributed in the hope that it will be useful,
 14     but WITHOUT ANY WARRANTY; without even the implied warranty of
 15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 16     GNU General Public License for more details.
 17 */
 18 /*
 19 Driver: cb_pcimdas
 20 Description: Measurement Computing PCI Migration series boards
 21 Devices: [ComputerBoards] PCIM-DAS1602/16 (cb_pcimdas)
 22 Author: Richard Bytheway
 23 Updated: Wed, 13 Nov 2002 12:34:56 +0000
 24 Status: experimental
 25 
 26 Written to support the PCIM-DAS1602/16 on a 2.4 series kernel.
 27 
 28 Configuration Options:
 29     [0] - PCI bus number
 30     [1] - PCI slot number
 31 
 32 Developed from cb_pcidas and skel by Richard Bytheway (mocelet@sucs.org).
 33 Only supports DIO, AO and simple AI in it's present form.
 34 No interrupts, multi channel or FIFO AI,
 35 although the card looks like it could support this.
 36 See http://www.mccdaq.com/PDFs/Manuals/pcim-das1602-16.pdf for more details.
 37 */
 38 
 39 #include <linux/module.h>
 40 #include <linux/pci.h>
 41 #include <linux/interrupt.h>
 42 
 43 #include "../comedidev.h"
 44 
 45 #include "plx9052.h"
 46 #include "8255.h"
 47 
 48 /* Registers for the PCIM-DAS1602/16 */
 49 
 50 /* DAC Offsets */
 51 #define ADC_TRIG 0
 52 #define DAC0_OFFSET 2
 53 #define DAC1_OFFSET 4
 54 
 55 /* AI and Counter Constants */
 56 #define MUX_LIMITS 0
 57 #define MAIN_CONN_DIO 1
 58 #define ADC_STAT 2
 59 #define ADC_CONV_STAT 3
 60 #define ADC_INT 4
 61 #define ADC_PACER 5
 62 #define BURST_MODE 6
 63 #define PROG_GAIN 7
 64 #define CLK8254_1_DATA 8
 65 #define CLK8254_2_DATA 9
 66 #define CLK8254_3_DATA 10
 67 #define CLK8254_CONTROL 11
 68 #define USER_COUNTER 12
 69 #define RESID_COUNT_H 13
 70 #define RESID_COUNT_L 14
 71 
 72 /*
 73  * this structure is for data unique to this hardware driver.  If
 74  * several hardware drivers keep similar information in this structure,
 75  * feel free to suggest moving the variable to the struct comedi_device
 76  * struct.
 77  */
 78 struct cb_pcimdas_private {
 79         /* base addresses */
 80         unsigned long BADR3;
 81 
 82         /* Used for AO readback */
 83         unsigned int ao_readback[2];
 84 };
 85 
 86 static int cb_pcimdas_ai_eoc(struct comedi_device *dev,
 87                              struct comedi_subdevice *s,
 88                              struct comedi_insn *insn,
 89                              unsigned long context)
 90 {
 91         struct cb_pcimdas_private *devpriv = dev->private;
 92         unsigned int status;
 93 
 94         status = inb(devpriv->BADR3 + 2);
 95         if ((status & 0x80) == 0)
 96                 return 0;
 97         return -EBUSY;
 98 }
 99 
100 static int cb_pcimdas_ai_rinsn(struct comedi_device *dev,
101                                struct comedi_subdevice *s,
102                                struct comedi_insn *insn, unsigned int *data)
103 {
104         struct cb_pcimdas_private *devpriv = dev->private;
105         int n;
106         unsigned int d;
107         int chan = CR_CHAN(insn->chanspec);
108         unsigned short chanlims;
109         int maxchans;
110         int ret;
111 
112         /*  only support sw initiated reads from a single channel */
113 
114         /* check channel number */
115         if ((inb(devpriv->BADR3 + 2) & 0x20) == 0)      /* differential mode */
116                 maxchans = s->n_chan / 2;
117         else
118                 maxchans = s->n_chan;
119 
120         if (chan > (maxchans - 1))
121                 return -ETIMEDOUT;      /* *** Wrong error code. Fixme. */
122 
123         /* configure for sw initiated read */
124         d = inb(devpriv->BADR3 + 5);
125         if ((d & 0x03) > 0) {   /* only reset if needed. */
126                 d = d & 0xfd;
127                 outb(d, devpriv->BADR3 + 5);
128         }
129 
130         /* set bursting off, conversions on */
131         outb(0x01, devpriv->BADR3 + 6);
132 
133         /* set range to 10V. UP/BP is controlled by a switch on the board */
134         outb(0x00, devpriv->BADR3 + 7);
135 
136         /*
137          * write channel limits to multiplexer, set Low (bits 0-3) and
138          * High (bits 4-7) channels to chan.
139          */
140         chanlims = chan | (chan << 4);
141         outb(chanlims, devpriv->BADR3 + 0);
142 
143         /* convert n samples */
144         for (n = 0; n < insn->n; n++) {
145                 /* trigger conversion */
146                 outw(0, dev->iobase + 0);
147 
148                 /* wait for conversion to end */
149                 ret = comedi_timeout(dev, s, insn, cb_pcimdas_ai_eoc, 0);
150                 if (ret)
151                         return ret;
152 
153                 /* read data */
154                 data[n] = inw(dev->iobase + 0);
155         }
156 
157         /* return the number of samples read/written */
158         return n;
159 }
160 
161 static int cb_pcimdas_ao_winsn(struct comedi_device *dev,
162                                struct comedi_subdevice *s,
163                                struct comedi_insn *insn, unsigned int *data)
164 {
165         struct cb_pcimdas_private *devpriv = dev->private;
166         int i;
167         int chan = CR_CHAN(insn->chanspec);
168 
169         /* Writing a list of values to an AO channel is probably not
170          * very useful, but that's how the interface is defined. */
171         for (i = 0; i < insn->n; i++) {
172                 switch (chan) {
173                 case 0:
174                         outw(data[i] & 0x0FFF, dev->iobase + DAC0_OFFSET);
175                         break;
176                 case 1:
177                         outw(data[i] & 0x0FFF, dev->iobase + DAC1_OFFSET);
178                         break;
179                 default:
180                         return -1;
181                 }
182                 devpriv->ao_readback[chan] = data[i];
183         }
184 
185         /* return the number of samples read/written */
186         return i;
187 }
188 
189 /* AO subdevices should have a read insn as well as a write insn.
190  * Usually this means copying a value stored in devpriv. */
191 static int cb_pcimdas_ao_rinsn(struct comedi_device *dev,
192                                struct comedi_subdevice *s,
193                                struct comedi_insn *insn, unsigned int *data)
194 {
195         struct cb_pcimdas_private *devpriv = dev->private;
196         int i;
197         int chan = CR_CHAN(insn->chanspec);
198 
199         for (i = 0; i < insn->n; i++)
200                 data[i] = devpriv->ao_readback[chan];
201 
202         return i;
203 }
204 
205 static int cb_pcimdas_auto_attach(struct comedi_device *dev,
206                                             unsigned long context_unused)
207 {
208         struct pci_dev *pcidev = comedi_to_pci_dev(dev);
209         struct cb_pcimdas_private *devpriv;
210         struct comedi_subdevice *s;
211         unsigned long iobase_8255;
212         int ret;
213 
214         devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
215         if (!devpriv)
216                 return -ENOMEM;
217 
218         ret = comedi_pci_enable(dev);
219         if (ret)
220                 return ret;
221 
222         dev->iobase = pci_resource_start(pcidev, 2);
223         devpriv->BADR3 = pci_resource_start(pcidev, 3);
224         iobase_8255 = pci_resource_start(pcidev, 4);
225 
226         ret = comedi_alloc_subdevices(dev, 3);
227         if (ret)
228                 return ret;
229 
230         s = &dev->subdevices[0];
231         /* dev->read_subdev=s; */
232         /*  analog input subdevice */
233         s->type = COMEDI_SUBD_AI;
234         s->subdev_flags = SDF_READABLE | SDF_GROUND;
235         s->n_chan = 16;
236         s->maxdata = 0xffff;
237         s->range_table = &range_unknown;
238         s->len_chanlist = 1;    /*  This is the maximum chanlist length that */
239         /*  the board can handle */
240         s->insn_read = cb_pcimdas_ai_rinsn;
241 
242         s = &dev->subdevices[1];
243         /*  analog output subdevice */
244         s->type = COMEDI_SUBD_AO;
245         s->subdev_flags = SDF_WRITABLE;
246         s->n_chan = 2;
247         s->maxdata = 0xfff;
248         /* ranges are hardware settable, but not software readable. */
249         s->range_table = &range_unknown;
250         s->insn_write = &cb_pcimdas_ao_winsn;
251         s->insn_read = &cb_pcimdas_ao_rinsn;
252 
253         s = &dev->subdevices[2];
254         /* digital i/o subdevice */
255         ret = subdev_8255_init(dev, s, NULL, iobase_8255);
256         if (ret)
257                 return ret;
258 
259         return 0;
260 }
261 
262 static void cb_pcimdas_detach(struct comedi_device *dev)
263 {
264         if (dev->irq)
265                 free_irq(dev->irq, dev);
266         comedi_pci_disable(dev);
267 }
268 
269 static struct comedi_driver cb_pcimdas_driver = {
270         .driver_name    = "cb_pcimdas",
271         .module         = THIS_MODULE,
272         .auto_attach    = cb_pcimdas_auto_attach,
273         .detach         = cb_pcimdas_detach,
274 };
275 
276 static int cb_pcimdas_pci_probe(struct pci_dev *dev,
277                                 const struct pci_device_id *id)
278 {
279         return comedi_pci_auto_config(dev, &cb_pcimdas_driver,
280                                       id->driver_data);
281 }
282 
283 static const struct pci_device_id cb_pcimdas_pci_table[] = {
284         { PCI_DEVICE(PCI_VENDOR_ID_CB, 0x0056) },
285         { 0 }
286 };
287 MODULE_DEVICE_TABLE(pci, cb_pcimdas_pci_table);
288 
289 static struct pci_driver cb_pcimdas_pci_driver = {
290         .name           = "cb_pcimdas",
291         .id_table       = cb_pcimdas_pci_table,
292         .probe          = cb_pcimdas_pci_probe,
293         .remove         = comedi_pci_auto_unconfig,
294 };
295 module_comedi_pci_driver(cb_pcimdas_driver, cb_pcimdas_pci_driver);
296 
297 MODULE_AUTHOR("Comedi http://www.comedi.org");
298 MODULE_DESCRIPTION("Comedi low-level driver");
299 MODULE_LICENSE("GPL");
300 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us