2 comedi/drivers/daqboard2000.c
3 hardware driver for IOtech DAQboard/2000
5 COMEDI - Linux Control and Measurement Device Interface
6 Copyright (C) 1999 Anders Blomdell <anders.blomdell@control.lth.se>
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.
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.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 Description: IOTech DAQBoard/2000
26 Author: Anders Blomdell <anders.blomdell@control.lth.se>
28 Updated: Mon, 14 Apr 2008 15:28:52 +0100
29 Devices: [IOTech] DAQBoard/2000 (daqboard2000)
31 Much of the functionality of this driver was determined from reading
32 the source code for the Windows driver.
34 The FPGA on the board requires initialization code, which can
35 be loaded by comedi_config using the -i
36 option. The initialization code is available from http://www.comedi.org
37 in the comedi_nonfree_firmware tarball.
39 Configuration options:
40 [0] - PCI bus of device (optional)
41 [1] - PCI slot of device (optional)
42 If bus/slot is not specified, the first supported
43 PCI device found will be used.
46 This card was obviously never intended to leave the Windows world,
47 since it lacked all kind of hardware documentation (except for cable
48 pinouts, plug and pray has something to catch up with yet).
50 With some help from our swedish distributor, we got the Windows sourcecode
51 for the card, and here are the findings so far.
53 1. A good document that describes the PCI interface chip is found at:
54 http://plx.plxtech.com/download/9080/databook/9080db-106.pdf
56 2. The initialization done so far is:
57 a. program the FPGA (windows code sans a lot of error messages)
60 3. Analog out seems to work OK with DAC's disabled, if DAC's are enabled,
61 you have to output values to all enabled DAC's until result appears, I
62 guess that it has something to do with pacer clocks, but the source
63 gives me no clues. I'll keep it simple so far.
66 Each channel in the scanlist seems to be controlled by four
70 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
71 ! | | | ! | | | ! | | | ! | | | !
72 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
75 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
76 ! | | | ! | | | ! | | | ! | | | !
77 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
79 +------+------+ | | | | +-- Digital input (??)
80 | | | | +---- 10 us settling time
81 | | | +------ Suspend acquisition (last to scan)
82 | | +-------- Simultaneous sample and hold
83 | +---------- Signed data format
84 +------------------------- Correction offset low
87 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
88 ! | | | ! | | | ! | | | ! | | | !
89 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
91 +-----+ +--+--+ +++ +++ +--+--+
92 | | | | +----- Expansion channel
93 | | | +----------- Expansion gain
94 | | +--------------- Channel (low)
95 | +--------------------- Correction offset high
96 +----------------------------- Correction gain low
98 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
99 ! | | | ! | | | ! | | | ! | | | !
100 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
102 +------+------+ | | +-+-+ | | +-- Low bank enable
103 | | | | | +---- High bank enable
104 | | | | +------ Hi/low select
105 | | | +---------- Gain (1,?,2,4,8,16,32,64)
106 | | +-------------- differential/single ended
107 | +---------------- Unipolar
108 +------------------------- Correction gain high
110 999. The card seems to have an incredible amount of capabilities, but
111 trying to reverse engineer them from the Windows source is beyond my
116 #include "../comedidev.h"
118 #include <linux/delay.h>
119 #include <linux/interrupt.h>
121 #include "comedi_pci.h"
124 #define DAQBOARD2000_SUBSYSTEM_IDS2 0x00021616 /* Daqboard/2000 - 2 Dacs */
125 #define DAQBOARD2000_SUBSYSTEM_IDS4 0x00041616 /* Daqboard/2000 - 4 Dacs */
127 #define DAQBOARD2000_DAQ_SIZE 0x1002
128 #define DAQBOARD2000_PLX_SIZE 0x100
130 /* Initialization bits for the Serial EEPROM Control Register */
131 #define DAQBOARD2000_SECRProgPinHi 0x8001767e
132 #define DAQBOARD2000_SECRProgPinLo 0x8000767e
133 #define DAQBOARD2000_SECRLocalBusHi 0xc000767e
134 #define DAQBOARD2000_SECRLocalBusLo 0x8000767e
135 #define DAQBOARD2000_SECRReloadHi 0xa000767e
136 #define DAQBOARD2000_SECRReloadLo 0x8000767e
138 /* SECR status bits */
139 #define DAQBOARD2000_EEPROM_PRESENT 0x10000000
141 /* CPLD status bits */
142 #define DAQBOARD2000_CPLD_INIT 0x0002
143 #define DAQBOARD2000_CPLD_DONE 0x0004
145 /* Available ranges */
146 static const struct comedi_lrange range_daqboard2000_ai = { 13, {
170 static const struct comedi_lrange range_daqboard2000_ao = { 1, {
175 struct daqboard2000_hw {
176 volatile u16 acqControl; /* 0x00 */
177 volatile u16 acqScanListFIFO; /* 0x02 */
178 volatile u32 acqPacerClockDivLow; /* 0x04 */
180 volatile u16 acqScanCounter; /* 0x08 */
181 volatile u16 acqPacerClockDivHigh; /* 0x0a */
182 volatile u16 acqTriggerCount; /* 0x0c */
183 volatile u16 fill2; /* 0x0e */
184 volatile u16 acqResultsFIFO; /* 0x10 */
185 volatile u16 fill3; /* 0x12 */
186 volatile u16 acqResultsShadow; /* 0x14 */
187 volatile u16 fill4; /* 0x16 */
188 volatile u16 acqAdcResult; /* 0x18 */
189 volatile u16 fill5; /* 0x1a */
190 volatile u16 dacScanCounter; /* 0x1c */
191 volatile u16 fill6; /* 0x1e */
193 volatile u16 dacControl; /* 0x20 */
194 volatile u16 fill7; /* 0x22 */
195 volatile s16 dacFIFO; /* 0x24 */
196 volatile u16 fill8[2]; /* 0x26 */
197 volatile u16 dacPacerClockDiv; /* 0x2a */
198 volatile u16 refDacs; /* 0x2c */
199 volatile u16 fill9; /* 0x2e */
201 volatile u16 dioControl; /* 0x30 */
202 volatile s16 dioP3hsioData; /* 0x32 */
203 volatile u16 dioP3Control; /* 0x34 */
204 volatile u16 calEepromControl; /* 0x36 */
205 volatile s16 dacSetting[4]; /* 0x38 */
206 volatile s16 dioP2ExpansionIO8Bit[32]; /* 0x40 */
208 volatile u16 ctrTmrControl; /* 0x80 */
209 volatile u16 fill10[3]; /* 0x82 */
210 volatile s16 ctrInput[4]; /* 0x88 */
211 volatile u16 fill11[8]; /* 0x90 */
212 volatile u16 timerDivisor[2]; /* 0xa0 */
213 volatile u16 fill12[6]; /* 0xa4 */
215 volatile u16 dmaControl; /* 0xb0 */
216 volatile u16 trigControl; /* 0xb2 */
217 volatile u16 fill13[2]; /* 0xb4 */
218 volatile u16 calEeprom; /* 0xb8 */
219 volatile u16 acqDigitalMark; /* 0xba */
220 volatile u16 trigDacs; /* 0xbc */
221 volatile u16 fill14; /* 0xbe */
222 volatile s16 dioP2ExpansionIO16Bit[32]; /* 0xc0 */
225 /* Scan Sequencer programming */
226 #define DAQBOARD2000_SeqStartScanList 0x0011
227 #define DAQBOARD2000_SeqStopScanList 0x0010
229 /* Prepare for acquisition */
230 #define DAQBOARD2000_AcqResetScanListFifo 0x0004
231 #define DAQBOARD2000_AcqResetResultsFifo 0x0002
232 #define DAQBOARD2000_AcqResetConfigPipe 0x0001
234 /* Acqusition status bits */
235 #define DAQBOARD2000_AcqResultsFIFOMore1Sample 0x0001
236 #define DAQBOARD2000_AcqResultsFIFOHasValidData 0x0002
237 #define DAQBOARD2000_AcqResultsFIFOOverrun 0x0004
238 #define DAQBOARD2000_AcqLogicScanning 0x0008
239 #define DAQBOARD2000_AcqConfigPipeFull 0x0010
240 #define DAQBOARD2000_AcqScanListFIFOEmpty 0x0020
241 #define DAQBOARD2000_AcqAdcNotReady 0x0040
242 #define DAQBOARD2000_ArbitrationFailure 0x0080
243 #define DAQBOARD2000_AcqPacerOverrun 0x0100
244 #define DAQBOARD2000_DacPacerOverrun 0x0200
245 #define DAQBOARD2000_AcqHardwareError 0x01c0
247 /* Scan Sequencer programming */
248 #define DAQBOARD2000_SeqStartScanList 0x0011
249 #define DAQBOARD2000_SeqStopScanList 0x0010
251 /* Pacer Clock Control */
252 #define DAQBOARD2000_AdcPacerInternal 0x0030
253 #define DAQBOARD2000_AdcPacerExternal 0x0032
254 #define DAQBOARD2000_AdcPacerEnable 0x0031
255 #define DAQBOARD2000_AdcPacerEnableDacPacer 0x0034
256 #define DAQBOARD2000_AdcPacerDisable 0x0030
257 #define DAQBOARD2000_AdcPacerNormalMode 0x0060
258 #define DAQBOARD2000_AdcPacerCompatibilityMode 0x0061
259 #define DAQBOARD2000_AdcPacerInternalOutEnable 0x0008
260 #define DAQBOARD2000_AdcPacerExternalRising 0x0100
263 #define DAQBOARD2000_DacFull 0x0001
264 #define DAQBOARD2000_RefBusy 0x0002
265 #define DAQBOARD2000_TrgBusy 0x0004
266 #define DAQBOARD2000_CalBusy 0x0008
267 #define DAQBOARD2000_Dac0Busy 0x0010
268 #define DAQBOARD2000_Dac1Busy 0x0020
269 #define DAQBOARD2000_Dac2Busy 0x0040
270 #define DAQBOARD2000_Dac3Busy 0x0080
273 #define DAQBOARD2000_Dac0Enable 0x0021
274 #define DAQBOARD2000_Dac1Enable 0x0031
275 #define DAQBOARD2000_Dac2Enable 0x0041
276 #define DAQBOARD2000_Dac3Enable 0x0051
277 #define DAQBOARD2000_DacEnableBit 0x0001
278 #define DAQBOARD2000_Dac0Disable 0x0020
279 #define DAQBOARD2000_Dac1Disable 0x0030
280 #define DAQBOARD2000_Dac2Disable 0x0040
281 #define DAQBOARD2000_Dac3Disable 0x0050
282 #define DAQBOARD2000_DacResetFifo 0x0004
283 #define DAQBOARD2000_DacPatternDisable 0x0060
284 #define DAQBOARD2000_DacPatternEnable 0x0061
285 #define DAQBOARD2000_DacSelectSignedData 0x0002
286 #define DAQBOARD2000_DacSelectUnsignedData 0x0000
288 /* Trigger Control */
289 #define DAQBOARD2000_TrigAnalog 0x0000
290 #define DAQBOARD2000_TrigTTL 0x0010
291 #define DAQBOARD2000_TrigTransHiLo 0x0004
292 #define DAQBOARD2000_TrigTransLoHi 0x0000
293 #define DAQBOARD2000_TrigAbove 0x0000
294 #define DAQBOARD2000_TrigBelow 0x0004
295 #define DAQBOARD2000_TrigLevelSense 0x0002
296 #define DAQBOARD2000_TrigEdgeSense 0x0000
297 #define DAQBOARD2000_TrigEnable 0x0001
298 #define DAQBOARD2000_TrigDisable 0x0000
300 /* Reference Dac Selection */
301 #define DAQBOARD2000_PosRefDacSelect 0x0100
302 #define DAQBOARD2000_NegRefDacSelect 0x0000
304 static int daqboard2000_attach(struct comedi_device *dev,
305 struct comedi_devconfig *it);
306 static int daqboard2000_detach(struct comedi_device *dev);
308 static struct comedi_driver driver_daqboard2000 = {
309 .driver_name = "daqboard2000",
310 .module = THIS_MODULE,
311 .attach = daqboard2000_attach,
312 .detach = daqboard2000_detach,
315 struct daq200_boardtype {
319 static const struct daq200_boardtype boardtypes[] = {
320 {"ids2", DAQBOARD2000_SUBSYSTEM_IDS2},
321 {"ids4", DAQBOARD2000_SUBSYSTEM_IDS4},
324 #define n_boardtypes (sizeof(boardtypes)/sizeof(struct daq200_boardtype))
325 #define this_board ((const struct daq200_boardtype *)dev->board_ptr)
327 static DEFINE_PCI_DEVICE_TABLE(daqboard2000_pci_table) = {
329 0x1616, 0x0409, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
333 MODULE_DEVICE_TABLE(pci, daqboard2000_pci_table);
335 struct daqboard2000_private {
339 struct pci_dev *pci_dev;
343 unsigned int ao_readback[2];
346 #define devpriv ((struct daqboard2000_private *)dev->private)
348 static void writeAcqScanListEntry(struct comedi_device *dev, u16 entry)
350 struct daqboard2000_hw *fpga = devpriv->daq;
353 fpga->acqScanListFIFO = entry & 0x00ff;
355 fpga->acqScanListFIFO = (entry >> 8) & 0x00ff;
358 static void setup_sampling(struct comedi_device *dev, int chan, int gain)
360 u16 word0, word1, word2, word3;
362 /* Channel 0-7 diff, channel 8-23 single ended */
364 word1 = 0x0004; /* Last scan */
365 word2 = (chan << 6) & 0x00c0;
390 dev->eeprom.correctionDACSE[i][j][k].offset = 0x800;
391 dev->eeprom.correctionDACSE[i][j][k].gain = 0xc00;
393 /* These should be read from EEPROM */
396 /* printk("%d %4.4x %4.4x %4.4x %4.4x\n", chan, word0, word1, word2, word3);*/
397 writeAcqScanListEntry(dev, word0);
398 writeAcqScanListEntry(dev, word1);
399 writeAcqScanListEntry(dev, word2);
400 writeAcqScanListEntry(dev, word3);
403 static int daqboard2000_ai_insn_read(struct comedi_device *dev,
404 struct comedi_subdevice *s,
405 struct comedi_insn *insn,
409 struct daqboard2000_hw *fpga = devpriv->daq;
410 int gain, chan, timeout;
413 DAQBOARD2000_AcqResetScanListFifo |
414 DAQBOARD2000_AcqResetResultsFifo | DAQBOARD2000_AcqResetConfigPipe;
416 /* If pacer clock is not set to some high value (> 10 us), we
417 risk multiple samples to be put into the result FIFO. */
418 fpga->acqPacerClockDivLow = 1000000; /* 1 second, should be long enough */
419 fpga->acqPacerClockDivHigh = 0;
421 gain = CR_RANGE(insn->chanspec);
422 chan = CR_CHAN(insn->chanspec);
424 /* This doesn't look efficient. I decided to take the conservative
425 * approach when I did the insn conversion. Perhaps it would be
426 * better to have broken it completely, then someone would have been
427 * forced to fix it. --ds */
428 for (i = 0; i < insn->n; i++) {
429 setup_sampling(dev, chan, gain);
430 /* Enable reading from the scanlist FIFO */
431 fpga->acqControl = DAQBOARD2000_SeqStartScanList;
432 for (timeout = 0; timeout < 20; timeout++) {
433 if (fpga->acqControl & DAQBOARD2000_AcqConfigPipeFull) {
438 fpga->acqControl = DAQBOARD2000_AdcPacerEnable;
439 for (timeout = 0; timeout < 20; timeout++) {
440 if (fpga->acqControl & DAQBOARD2000_AcqLogicScanning) {
445 for (timeout = 0; timeout < 20; timeout++) {
446 if (fpga->acqControl &
447 DAQBOARD2000_AcqResultsFIFOHasValidData) {
452 data[i] = fpga->acqResultsFIFO;
453 fpga->acqControl = DAQBOARD2000_AdcPacerDisable;
454 fpga->acqControl = DAQBOARD2000_SeqStopScanList;
460 static int daqboard2000_ao_insn_read(struct comedi_device *dev,
461 struct comedi_subdevice *s,
462 struct comedi_insn *insn,
466 int chan = CR_CHAN(insn->chanspec);
468 for (i = 0; i < insn->n; i++) {
469 data[i] = devpriv->ao_readback[chan];
475 static int daqboard2000_ao_insn_write(struct comedi_device *dev,
476 struct comedi_subdevice *s,
477 struct comedi_insn *insn,
481 int chan = CR_CHAN(insn->chanspec);
482 struct daqboard2000_hw *fpga = devpriv->daq;
485 for (i = 0; i < insn->n; i++) {
487 * OK, since it works OK without enabling the DAC's, let's keep
488 * it as simple as possible...
490 /* fpga->dacControl = (chan + 2) * 0x0010 | 0x0001; udelay(1000); */
491 fpga->dacSetting[chan] = data[i];
492 for (timeout = 0; timeout < 20; timeout++) {
493 if ((fpga->dacControl & ((chan + 1) * 0x0010)) == 0) {
498 devpriv->ao_readback[chan] = data[i];
500 * Since we never enabled the DAC's, we don't need to disable it...
501 * fpga->dacControl = (chan + 2) * 0x0010 | 0x0000; udelay(1000);
508 static void daqboard2000_resetLocalBus(struct comedi_device *dev)
510 printk("daqboard2000_resetLocalBus\n");
511 writel(DAQBOARD2000_SECRLocalBusHi, devpriv->plx + 0x6c);
513 writel(DAQBOARD2000_SECRLocalBusLo, devpriv->plx + 0x6c);
517 static void daqboard2000_reloadPLX(struct comedi_device *dev)
519 printk("daqboard2000_reloadPLX\n");
520 writel(DAQBOARD2000_SECRReloadLo, devpriv->plx + 0x6c);
522 writel(DAQBOARD2000_SECRReloadHi, devpriv->plx + 0x6c);
524 writel(DAQBOARD2000_SECRReloadLo, devpriv->plx + 0x6c);
528 static void daqboard2000_pulseProgPin(struct comedi_device *dev)
530 printk("daqboard2000_pulseProgPin 1\n");
531 writel(DAQBOARD2000_SECRProgPinHi, devpriv->plx + 0x6c);
533 writel(DAQBOARD2000_SECRProgPinLo, devpriv->plx + 0x6c);
534 udelay(10000); /* Not in the original code, but I like symmetry... */
537 static int daqboard2000_pollCPLD(struct comedi_device *dev, int mask)
543 /* timeout after 50 tries -> 5ms */
544 for (i = 0; i < 50; i++) {
545 cpld = readw(devpriv->daq + 0x1000);
546 if ((cpld & mask) == mask) {
556 static int daqboard2000_writeCPLD(struct comedi_device *dev, int data)
561 writew(data, devpriv->daq + 0x1000);
562 if ((readw(devpriv->daq + 0x1000) & DAQBOARD2000_CPLD_INIT) ==
563 DAQBOARD2000_CPLD_INIT) {
569 static int initialize_daqboard2000(struct comedi_device *dev,
570 unsigned char *cpld_array, int len)
573 /* Read the serial EEPROM control register */
578 /* Check to make sure the serial eeprom is present on the board */
579 secr = readl(devpriv->plx + 0x6c);
580 if (!(secr & DAQBOARD2000_EEPROM_PRESENT)) {
582 printk("no serial eeprom\n");
587 for (retry = 0; retry < 3; retry++) {
589 printk("Programming EEPROM try %x\n", retry);
592 daqboard2000_resetLocalBus(dev);
593 daqboard2000_reloadPLX(dev);
594 daqboard2000_pulseProgPin(dev);
595 if (daqboard2000_pollCPLD(dev, DAQBOARD2000_CPLD_INIT)) {
596 for (i = 0; i < len; i++) {
597 if (cpld_array[i] == 0xff
598 && cpld_array[i + 1] == 0x20) {
600 printk("Preamble found at %d\n", i);
605 for (; i < len; i += 2) {
607 (cpld_array[i] << 8) + cpld_array[i + 1];
608 if (!daqboard2000_writeCPLD(dev, data)) {
614 printk("Programmed\n");
616 daqboard2000_resetLocalBus(dev);
617 daqboard2000_reloadPLX(dev);
626 static void daqboard2000_adcStopDmaTransfer(struct comedi_device *dev)
628 /* printk("Implement: daqboard2000_adcStopDmaTransfer\n");*/
631 static void daqboard2000_adcDisarm(struct comedi_device *dev)
633 struct daqboard2000_hw *fpga = devpriv->daq;
635 /* Disable hardware triggers */
637 fpga->trigControl = DAQBOARD2000_TrigAnalog | DAQBOARD2000_TrigDisable;
639 fpga->trigControl = DAQBOARD2000_TrigTTL | DAQBOARD2000_TrigDisable;
641 /* Stop the scan list FIFO from loading the configuration pipe */
643 fpga->acqControl = DAQBOARD2000_SeqStopScanList;
645 /* Stop the pacer clock */
647 fpga->acqControl = DAQBOARD2000_AdcPacerDisable;
649 /* Stop the input dma (abort channel 1) */
650 daqboard2000_adcStopDmaTransfer(dev);
653 static void daqboard2000_activateReferenceDacs(struct comedi_device *dev)
655 struct daqboard2000_hw *fpga = devpriv->daq;
658 /* Set the + reference dac value in the FPGA */
659 fpga->refDacs = 0x80 | DAQBOARD2000_PosRefDacSelect;
660 for (timeout = 0; timeout < 20; timeout++) {
661 if ((fpga->dacControl & DAQBOARD2000_RefBusy) == 0) {
666 /* printk("DAQBOARD2000_PosRefDacSelect %d\n", timeout);*/
668 /* Set the - reference dac value in the FPGA */
669 fpga->refDacs = 0x80 | DAQBOARD2000_NegRefDacSelect;
670 for (timeout = 0; timeout < 20; timeout++) {
671 if ((fpga->dacControl & DAQBOARD2000_RefBusy) == 0) {
676 /* printk("DAQBOARD2000_NegRefDacSelect %d\n", timeout);*/
679 static void daqboard2000_initializeCtrs(struct comedi_device *dev)
681 /* printk("Implement: daqboard2000_initializeCtrs\n");*/
684 static void daqboard2000_initializeTmrs(struct comedi_device *dev)
686 /* printk("Implement: daqboard2000_initializeTmrs\n");*/
689 static void daqboard2000_dacDisarm(struct comedi_device *dev)
691 /* printk("Implement: daqboard2000_dacDisarm\n");*/
694 static void daqboard2000_initializeAdc(struct comedi_device *dev)
696 daqboard2000_adcDisarm(dev);
697 daqboard2000_activateReferenceDacs(dev);
698 daqboard2000_initializeCtrs(dev);
699 daqboard2000_initializeTmrs(dev);
702 static void daqboard2000_initializeDac(struct comedi_device *dev)
704 daqboard2000_dacDisarm(dev);
708 The test command, REMOVE!!:
710 rmmod daqboard2000 ; rmmod comedi; make install ; modprobe daqboard2000; /usr/sbin/comedi_config /dev/comedi0 daqboard/2000 ; tail -40 /var/log/messages
713 static int daqboard2000_8255_cb(int dir, int port, int data,
714 unsigned long ioaddr)
718 writew(data, ((void *)ioaddr) + port * 2);
721 result = readw(((void *)ioaddr) + port * 2);
724 printk("daqboard2000_8255_cb %x %d %d %2.2x -> %2.2x\n",
725 arg, dir, port, data, result);
730 static int daqboard2000_attach(struct comedi_device *dev,
731 struct comedi_devconfig *it)
734 struct comedi_subdevice *s;
735 struct pci_dev *card = NULL;
737 unsigned int aux_len;
740 printk("comedi%d: daqboard2000:", dev->minor);
742 bus = it->options[0];
743 slot = it->options[1];
745 result = alloc_private(dev, sizeof(struct daqboard2000_private));
749 for (card = pci_get_device(0x1616, 0x0409, NULL);
750 card != NULL; card = pci_get_device(0x1616, 0x0409, card)) {
752 /* requested particular bus/slot */
753 if (card->bus->number != bus ||
754 PCI_SLOT(card->devfn) != slot) {
758 break; /* found one */
762 printk(" no daqboard2000 found at bus/slot: %d/%d\n",
765 printk(" no daqboard2000 found\n");
770 devpriv->pci_dev = card;
772 subsystem_device << 16) | card->subsystem_vendor;
773 for (i = 0; i < n_boardtypes; i++) {
774 if (boardtypes[i].id == id) {
775 printk(" %s", boardtypes[i].name);
776 dev->board_ptr = boardtypes + i;
779 if (!dev->board_ptr) {
781 (" unknown subsystem id %08x (pretend it is an ids2)",
783 dev->board_ptr = boardtypes;
787 result = comedi_pci_enable(card, "daqboard2000");
789 printk(" failed to enable PCI device and request regions\n");
792 devpriv->got_regions = 1;
794 ioremap(pci_resource_start(card, 0), DAQBOARD2000_PLX_SIZE);
796 ioremap(pci_resource_start(card, 2), DAQBOARD2000_DAQ_SIZE);
797 if (!devpriv->plx || !devpriv->daq) {
801 result = alloc_subdevices(dev, 3);
805 readl(devpriv->plx + 0x6c);
809 Windows code does restore interrupts, but since we don't use them...
810 pci_read_config_byte(card, PCI_INTERRUPT_LINE, &interrupt);
811 printk("Interrupt before is: %x\n", interrupt);
814 aux_data = comedi_aux_data(it->options, 0);
815 aux_len = it->options[COMEDI_DEVCONF_AUX_DATA_LENGTH];
817 if (aux_data && aux_len) {
818 result = initialize_daqboard2000(dev, aux_data, aux_len);
820 printk("no FPGA initialization code, aborting\n");
825 daqboard2000_initializeAdc(dev);
826 daqboard2000_initializeDac(dev);
828 Windows code does restore interrupts, but since we don't use them...
829 pci_read_config_byte(card, PCI_INTERRUPT_LINE, &interrupt);
830 printk("Interrupt after is: %x\n", interrupt);
833 dev->iobase = (unsigned long)devpriv->daq;
835 dev->board_name = this_board->name;
837 s = dev->subdevices + 0;
839 s->type = COMEDI_SUBD_AI;
840 s->subdev_flags = SDF_READABLE | SDF_GROUND;
843 s->insn_read = daqboard2000_ai_insn_read;
844 s->range_table = &range_daqboard2000_ai;
846 s = dev->subdevices + 1;
848 s->type = COMEDI_SUBD_AO;
849 s->subdev_flags = SDF_WRITABLE;
852 s->insn_read = daqboard2000_ao_insn_read;
853 s->insn_write = daqboard2000_ao_insn_write;
854 s->range_table = &range_daqboard2000_ao;
856 s = dev->subdevices + 2;
857 result = subdev_8255_init(dev, s, daqboard2000_8255_cb,
858 (unsigned long)(dev->iobase + 0x40));
865 static int daqboard2000_detach(struct comedi_device *dev)
867 printk("comedi%d: daqboard2000: remove\n", dev->minor);
870 subdev_8255_cleanup(dev, dev->subdevices + 2);
873 free_irq(dev->irq, dev);
877 iounmap(devpriv->daq);
879 iounmap(devpriv->plx);
880 if (devpriv->pci_dev) {
881 if (devpriv->got_regions) {
882 comedi_pci_disable(devpriv->pci_dev);
884 pci_dev_put(devpriv->pci_dev);
890 static int __devinit driver_daqboard2000_pci_probe(struct pci_dev *dev,
891 const struct pci_device_id
894 return comedi_pci_auto_config(dev, driver_daqboard2000.driver_name);
897 static void __devexit driver_daqboard2000_pci_remove(struct pci_dev *dev)
899 comedi_pci_auto_unconfig(dev);
902 static struct pci_driver driver_daqboard2000_pci_driver = {
903 .id_table = daqboard2000_pci_table,
904 .probe = &driver_daqboard2000_pci_probe,
905 .remove = __devexit_p(&driver_daqboard2000_pci_remove)
908 static int __init driver_daqboard2000_init_module(void)
912 retval = comedi_driver_register(&driver_daqboard2000);
916 driver_daqboard2000_pci_driver.name =
917 (char *)driver_daqboard2000.driver_name;
918 return pci_register_driver(&driver_daqboard2000_pci_driver);
921 static void __exit driver_daqboard2000_cleanup_module(void)
923 pci_unregister_driver(&driver_daqboard2000_pci_driver);
924 comedi_driver_unregister(&driver_daqboard2000);
927 module_init(driver_daqboard2000_init_module);
928 module_exit(driver_daqboard2000_cleanup_module);
930 MODULE_AUTHOR("Comedi http://www.comedi.org");
931 MODULE_DESCRIPTION("Comedi low-level driver");
932 MODULE_LICENSE("GPL");