5 COMEDI - Linux Control and Measurement Device Interface
6 Copyright (C) 2000 David A. Schleef <ds@schleef.org>
7 Copyright (C) 2000 Chris R. Baugher <baugher@enteract.com>
8 Copyright (C) 2001,2002 Frank Mori Hess <fmhess@users.sourceforge.net>
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 ************************************************************************
28 Description: DAS16 compatible boards
29 Author: Sam Moore, Warren Jasper, ds, Chris Baugher, Frank Hess, Roman Fietze
30 Devices: [Keithley Metrabyte] DAS-16 (das-16), DAS-16G (das-16g),
31 DAS-16F (das-16f), DAS-1201 (das-1201), DAS-1202 (das-1202),
32 DAS-1401 (das-1401), DAS-1402 (das-1402), DAS-1601 (das-1601),
34 [ComputerBoards] PC104-DAS16/JR (pc104-das16jr),
35 PC104-DAS16JR/16 (pc104-das16jr/16),
36 CIO-DAS16JR/16 (cio-das16jr/16),
37 CIO-DAS16/JR (cio-das16/jr), CIO-DAS1401/12 (cio-das1401/12),
38 CIO-DAS1402/12 (cio-das1402/12), CIO-DAS1402/16 (cio-das1402/16),
39 CIO-DAS1601/12 (cio-das1601/12), CIO-DAS1602/12 (cio-das1602/12),
40 CIO-DAS1602/16 (cio-das1602/16), CIO-DAS16/330 (cio-das16/330)
44 A rewrite of the das16 and das1600 drivers.
47 [1] - irq (does nothing, irq is not used anymore)
48 [2] - dma (optional, required for comedi_command support)
49 [3] - master clock speed in MHz (optional, 1 or 10, ignored if
50 board can probe clock, defaults to 1)
51 [4] - analog input range lowest voltage in microvolts (optional,
52 only useful if your board does not have software
54 [5] - analog input range highest voltage in microvolts (optional,
55 only useful if board does not have software programmable
57 [6] - analog output range lowest voltage in microvolts (optional)
58 [7] - analog output range highest voltage in microvolts (optional)
59 [8] - use timer mode for DMA. Timer mode is needed e.g. for
60 buggy DMA controllers in NS CS5530A (Geode Companion), and for
61 'jr' cards that lack a hardware fifo. This option is no
62 longer needed, since timer mode is _always_ used.
64 Passing a zero for an option is the same as leaving it unspecified.
69 Testing and debugging help provided by Daniel Koch.
73 4919.PDF (das1400, 1600)
75 4923.PDF (das1200, 1400, 1600)
77 Computer boards manuals also available from their website
78 www.measurementcomputing.com
82 #include <linux/pci.h>
83 #include <linux/slab.h>
84 #include <linux/interrupt.h>
88 #include "../comedidev.h"
92 #include "comedi_fc.h"
98 #define DEBUG_PRINT(format, args...) \
99 printk(KERN_DEBUG "das16: " format, ## args)
101 #define DEBUG_PRINT(format, args...)
104 #define DAS16_SIZE 20 /* number of ioports */
105 #define DAS16_DMA_SIZE 0xff00 /* size in bytes of allocated dma buffer */
113 0 a/d bits 0-3 start 12 bit
114 1 a/d bits 4-11 unused
121 8 status eoc uni/bip interrupt reset
122 9 dma, int, trig ctrl set dma, int
123 a pacer control unused
135 0 a/d bits 0-3 start 12 bit
136 1 a/d bits 4-11 unused
140 8 status eoc uni/bip interrupt reset
141 9 dma, int, trig ctrl set dma, int
142 a pacer control unused
143 b gain status gain control
153 0 a/d bits 0-7 start 16 bit
154 1 a/d bits 8-15 unused
158 8 status eoc uni/bip interrupt reset
159 9 dma, int, trig ctrl set dma, int
160 a pacer control unused
161 b gain status gain control
172 0 a/d bits 0-3 start 12 bit
173 1 a/d bits 4-11 unused
180 8 status eoc uni/bip interrupt reset
181 9 dma, int, trig ctrl set dma, int
182 a pacer control unused
183 b gain status gain control
186 404 unused conversion enable
187 405 unused burst enable
188 406 unused das1600 enable
193 /* size in bytes of a sample from board */
194 static const int sample_size = 2;
197 #define DAS16_AI_LSB 0
198 #define DAS16_AI_MSB 1
201 #define DAS16_AO_LSB(x) ((x) ? 6 : 4)
202 #define DAS16_AO_MSB(x) ((x) ? 7 : 5)
203 #define DAS16_STATUS 8
205 #define UNIPOLAR (1<<6)
206 #define DAS16_MUXBIT (1<<5)
207 #define DAS16_INT (1<<4)
208 #define DAS16_CONTROL 9
209 #define DAS16_INTE (1<<7)
210 #define DAS16_IRQ(x) (((x) & 0x7) << 4)
211 #define DMA_ENABLE (1<<2)
212 #define PACING_MASK 0x3
213 #define INT_PACER 0x03
214 #define EXT_PACER 0x02
215 #define DAS16_SOFT 0x00
216 #define DAS16_PACER 0x0A
217 #define DAS16_CTR0 (1<<1)
218 #define DAS16_TRIG0 (1<<0)
219 #define BURST_LEN_BITS(x) (((x) & 0xf) << 4)
220 #define DAS16_GAIN 0x0B
221 #define DAS16_CNTR0_DATA 0x0C
222 #define DAS16_CNTR1_DATA 0x0D
223 #define DAS16_CNTR2_DATA 0x0E
224 #define DAS16_CNTR_CONTROL 0x0F
225 #define DAS16_TERM_CNT 0x00
226 #define DAS16_ONE_SHOT 0x02
227 #define DAS16_RATE_GEN 0x04
228 #define DAS16_CNTR_LSB_MSB 0x30
229 #define DAS16_CNTR0 0x00
230 #define DAS16_CNTR1 0x40
231 #define DAS16_CNTR2 0x80
233 #define DAS1600_CONV 0x404
234 #define DAS1600_CONV_DISABLE 0x40
235 #define DAS1600_BURST 0x405
236 #define DAS1600_BURST_VAL 0x40
237 #define DAS1600_ENABLE 0x406
238 #define DAS1600_ENABLE_VAL 0x40
239 #define DAS1600_STATUS_B 0x407
240 #define DAS1600_BME 0x40
241 #define DAS1600_ME 0x20
242 #define DAS1600_CD 0x10
243 #define DAS1600_WS 0x02
244 #define DAS1600_CLK_10MHZ 0x01
246 static const struct comedi_lrange range_das1x01_bip = { 4, {
254 static const struct comedi_lrange range_das1x01_unip = { 4, {
262 static const struct comedi_lrange range_das1x02_bip = { 4, {
270 static const struct comedi_lrange range_das1x02_unip = { 4, {
278 static const struct comedi_lrange range_das16jr = { 9, {
279 /* also used by 16/330 */
292 static const struct comedi_lrange range_das16jr_16 = { 8, {
304 static const int das16jr_gainlist[] = { 8, 0, 1, 2, 3, 4, 5, 6, 7 };
305 static const int das16jr_16_gainlist[] = { 0, 1, 2, 3, 4, 5, 6, 7 };
306 static const int das1600_gainlist[] = { 0, 1, 2, 3 };
315 static const int *const das16_gainlists[] = {
323 static const struct comedi_lrange *const das16_ai_uni_lranges[] = {
331 static const struct comedi_lrange *const das16_ai_bip_lranges[] = {
341 unsigned have_byte:1;
347 unsigned int ai_nbits;
348 unsigned int ai_speed; /* max conversion speed in nanosec */
351 unsigned int ao_nbits;
355 unsigned int i8255_offset;
356 unsigned int i8254_offset;
362 #define DAS16_TIMEOUT 1000
364 /* Period for timer interrupt in jiffies. It's a function
365 * to deal with possibility of dynamic HZ patches */
366 static inline int timer_period(void)
371 struct das16_private_struct {
372 unsigned int ai_unipolar; /* unipolar flag */
373 unsigned int ai_singleended; /* single ended flag */
374 unsigned int clockbase; /* master clock speed in ns */
375 volatile unsigned int control_state; /* dma, interrupt and trigger control bits */
376 volatile unsigned long adc_byte_count; /* number of bytes remaining */
377 /* divisor dividing master clock to get conversion frequency */
378 unsigned int divisor1;
379 /* divisor dividing master clock to get conversion frequency */
380 unsigned int divisor2;
381 unsigned int dma_chan; /* dma channel */
382 uint16_t *dma_buffer[2];
383 dma_addr_t dma_buffer_addr[2];
384 unsigned int current_buffer;
385 volatile unsigned int dma_transfer_size; /* target number of bytes to transfer per dma shot */
387 * user-defined analog input and output ranges
388 * defined from config options
390 struct comedi_lrange *user_ai_range_table;
391 struct comedi_lrange *user_ao_range_table;
393 struct timer_list timer; /* for timed interrupt */
394 volatile short timer_running;
395 volatile short timer_mode; /* true if using timer mode */
398 static int das16_cmd_test(struct comedi_device *dev, struct comedi_subdevice *s,
399 struct comedi_cmd *cmd)
401 const struct das16_board *board = comedi_board(dev);
402 struct das16_private_struct *devpriv = dev->private;
404 int gain, start_chan, i;
407 /* Step 1 : check if triggers are trivially valid */
409 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
412 /* if board supports burst mode */
413 if (board->size > 0x400)
414 mask |= TRIG_TIMER | TRIG_EXT;
415 err |= cfc_check_trigger_src(&cmd->scan_begin_src, mask);
417 tmp = cmd->convert_src;
418 mask = TRIG_TIMER | TRIG_EXT;
419 /* if board supports burst mode */
420 if (board->size > 0x400)
422 err |= cfc_check_trigger_src(&cmd->convert_src, mask);
424 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
425 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
430 /* Step 2a : make sure trigger sources are unique */
432 err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
433 err |= cfc_check_trigger_is_unique(cmd->convert_src);
434 err |= cfc_check_trigger_is_unique(cmd->stop_src);
436 /* Step 2b : and mutually compatible */
438 /* make sure scan_begin_src and convert_src dont conflict */
439 if (cmd->scan_begin_src == TRIG_FOLLOW && cmd->convert_src == TRIG_NOW)
441 if (cmd->scan_begin_src != TRIG_FOLLOW && cmd->convert_src != TRIG_NOW)
447 /* Step 3: check if arguments are trivially valid */
449 err |= cfc_check_trigger_arg_is(&cmd->start_arg, 0);
451 if (cmd->scan_begin_src == TRIG_FOLLOW) /* internal trigger */
452 err |= cfc_check_trigger_arg_is(&cmd->scan_begin_arg, 0);
454 err |= cfc_check_trigger_arg_is(&cmd->scan_end_arg, cmd->chanlist_len);
456 /* check against maximum frequency */
457 if (cmd->scan_begin_src == TRIG_TIMER)
458 err |= cfc_check_trigger_arg_min(&cmd->scan_begin_arg,
459 board->ai_speed * cmd->chanlist_len);
461 if (cmd->convert_src == TRIG_TIMER)
462 err |= cfc_check_trigger_arg_min(&cmd->convert_arg,
465 if (cmd->stop_src == TRIG_NONE)
466 err |= cfc_check_trigger_arg_is(&cmd->stop_arg, 0);
471 /* step 4: fix up arguments */
472 if (cmd->scan_begin_src == TRIG_TIMER) {
473 unsigned int tmp = cmd->scan_begin_arg;
474 /* set divisors, correct timing arguments */
475 i8253_cascade_ns_to_timer_2div(devpriv->clockbase,
476 &(devpriv->divisor1),
477 &(devpriv->divisor2),
478 &(cmd->scan_begin_arg),
479 cmd->flags & TRIG_ROUND_MASK);
480 err += (tmp != cmd->scan_begin_arg);
482 if (cmd->convert_src == TRIG_TIMER) {
483 unsigned int tmp = cmd->convert_arg;
484 /* set divisors, correct timing arguments */
485 i8253_cascade_ns_to_timer_2div(devpriv->clockbase,
486 &(devpriv->divisor1),
487 &(devpriv->divisor2),
489 cmd->flags & TRIG_ROUND_MASK);
490 err += (tmp != cmd->convert_arg);
495 /* check channel/gain list against card's limitations */
497 gain = CR_RANGE(cmd->chanlist[0]);
498 start_chan = CR_CHAN(cmd->chanlist[0]);
499 for (i = 1; i < cmd->chanlist_len; i++) {
500 if (CR_CHAN(cmd->chanlist[i]) !=
501 (start_chan + i) % s->n_chan) {
503 "entries in chanlist must be "
504 "consecutive channels, "
505 "counting upwards\n");
508 if (CR_RANGE(cmd->chanlist[i]) != gain) {
510 "entries in chanlist must all "
511 "have the same gain\n");
522 /* utility function that suggests a dma transfer size in bytes */
523 static unsigned int das16_suggest_transfer_size(struct comedi_device *dev,
524 const struct comedi_cmd *cmd)
526 struct das16_private_struct *devpriv = dev->private;
530 /* if we are using timer interrupt, we don't care how long it
531 * will take to complete transfer since it will be interrupted
532 * by timer interrupt */
533 if (devpriv->timer_mode)
534 return DAS16_DMA_SIZE;
536 /* otherwise, we are relying on dma terminal count interrupt,
537 * so pick a reasonable size */
538 if (cmd->convert_src == TRIG_TIMER)
539 freq = 1000000000 / cmd->convert_arg;
540 else if (cmd->scan_begin_src == TRIG_TIMER)
541 freq = (1000000000 / cmd->scan_begin_arg) * cmd->chanlist_len;
542 /* return some default value */
546 if (cmd->flags & TRIG_WAKE_EOS) {
547 size = sample_size * cmd->chanlist_len;
549 /* make buffer fill in no more than 1/3 second */
550 size = (freq / 3) * sample_size;
553 /* set a minimum and maximum size allowed */
554 if (size > DAS16_DMA_SIZE)
555 size = DAS16_DMA_SIZE - DAS16_DMA_SIZE % sample_size;
556 else if (size < sample_size)
559 if (cmd->stop_src == TRIG_COUNT && size > devpriv->adc_byte_count)
560 size = devpriv->adc_byte_count;
565 static unsigned int das16_set_pacer(struct comedi_device *dev, unsigned int ns,
568 struct das16_private_struct *devpriv = dev->private;
570 i8253_cascade_ns_to_timer_2div(devpriv->clockbase, &(devpriv->divisor1),
571 &(devpriv->divisor2), &ns,
572 rounding_flags & TRIG_ROUND_MASK);
574 /* Write the values of ctr1 and ctr2 into counters 1 and 2 */
575 i8254_load(dev->iobase + DAS16_CNTR0_DATA, 0, 1, devpriv->divisor1, 2);
576 i8254_load(dev->iobase + DAS16_CNTR0_DATA, 0, 2, devpriv->divisor2, 2);
581 static int das16_cmd_exec(struct comedi_device *dev, struct comedi_subdevice *s)
583 const struct das16_board *board = comedi_board(dev);
584 struct das16_private_struct *devpriv = dev->private;
585 struct comedi_async *async = s->async;
586 struct comedi_cmd *cmd = &async->cmd;
591 if (devpriv->dma_chan == 0 || (dev->irq == 0
592 && devpriv->timer_mode == 0)) {
594 "irq (or use of 'timer mode') dma required to "
595 "execute comedi_cmd");
598 if (cmd->flags & TRIG_RT) {
599 comedi_error(dev, "isa dma transfers cannot be performed with "
600 "TRIG_RT, aborting");
604 devpriv->adc_byte_count =
605 cmd->stop_arg * cmd->chanlist_len * sizeof(uint16_t);
607 /* disable conversions for das1600 mode */
608 if (board->size > 0x400)
609 outb(DAS1600_CONV_DISABLE, dev->iobase + DAS1600_CONV);
611 /* set scan limits */
612 byte = CR_CHAN(cmd->chanlist[0]);
613 byte |= CR_CHAN(cmd->chanlist[cmd->chanlist_len - 1]) << 4;
614 outb(byte, dev->iobase + DAS16_MUX);
616 /* set gain (this is also burst rate register but according to
617 * computer boards manual, burst rate does nothing, even on
619 if (board->ai_pg != das16_pg_none) {
620 range = CR_RANGE(cmd->chanlist[0]);
621 outb((das16_gainlists[board->ai_pg])[range],
622 dev->iobase + DAS16_GAIN);
625 /* set counter mode and counts */
627 das16_set_pacer(dev, cmd->convert_arg,
628 cmd->flags & TRIG_ROUND_MASK);
629 DEBUG_PRINT("pacer period: %d ns\n", cmd->convert_arg);
631 /* enable counters */
633 /* Enable burst mode if appropriate. */
634 if (board->size > 0x400) {
635 if (cmd->convert_src == TRIG_NOW) {
636 outb(DAS1600_BURST_VAL, dev->iobase + DAS1600_BURST);
637 /* set burst length */
638 byte |= BURST_LEN_BITS(cmd->chanlist_len - 1);
640 outb(0, dev->iobase + DAS1600_BURST);
643 outb(byte, dev->iobase + DAS16_PACER);
645 /* set up dma transfer */
646 flags = claim_dma_lock();
647 disable_dma(devpriv->dma_chan);
648 /* clear flip-flop to make sure 2-byte registers for
649 * count and address get set correctly */
650 clear_dma_ff(devpriv->dma_chan);
651 devpriv->current_buffer = 0;
652 set_dma_addr(devpriv->dma_chan,
653 devpriv->dma_buffer_addr[devpriv->current_buffer]);
654 /* set appropriate size of transfer */
655 devpriv->dma_transfer_size = das16_suggest_transfer_size(dev, cmd);
656 set_dma_count(devpriv->dma_chan, devpriv->dma_transfer_size);
657 enable_dma(devpriv->dma_chan);
658 release_dma_lock(flags);
660 /* set up interrupt */
661 if (devpriv->timer_mode) {
662 devpriv->timer_running = 1;
663 devpriv->timer.expires = jiffies + timer_period();
664 add_timer(&devpriv->timer);
665 devpriv->control_state &= ~DAS16_INTE;
667 /* clear interrupt bit */
668 outb(0x00, dev->iobase + DAS16_STATUS);
669 /* enable interrupts */
670 devpriv->control_state |= DAS16_INTE;
672 devpriv->control_state |= DMA_ENABLE;
673 devpriv->control_state &= ~PACING_MASK;
674 if (cmd->convert_src == TRIG_EXT)
675 devpriv->control_state |= EXT_PACER;
677 devpriv->control_state |= INT_PACER;
678 outb(devpriv->control_state, dev->iobase + DAS16_CONTROL);
680 /* Enable conversions if using das1600 mode */
681 if (board->size > 0x400)
682 outb(0, dev->iobase + DAS1600_CONV);
688 static int das16_cancel(struct comedi_device *dev, struct comedi_subdevice *s)
690 const struct das16_board *board = comedi_board(dev);
691 struct das16_private_struct *devpriv = dev->private;
694 spin_lock_irqsave(&dev->spinlock, flags);
695 /* disable interrupts, dma and pacer clocked conversions */
696 devpriv->control_state &= ~DAS16_INTE & ~PACING_MASK & ~DMA_ENABLE;
697 outb(devpriv->control_state, dev->iobase + DAS16_CONTROL);
698 if (devpriv->dma_chan)
699 disable_dma(devpriv->dma_chan);
701 /* disable SW timer */
702 if (devpriv->timer_mode && devpriv->timer_running) {
703 devpriv->timer_running = 0;
704 del_timer(&devpriv->timer);
707 /* disable burst mode */
708 if (board->size > 0x400)
709 outb(0, dev->iobase + DAS1600_BURST);
712 spin_unlock_irqrestore(&dev->spinlock, flags);
717 static void das16_reset(struct comedi_device *dev)
719 outb(0, dev->iobase + DAS16_STATUS);
720 outb(0, dev->iobase + DAS16_CONTROL);
721 outb(0, dev->iobase + DAS16_PACER);
722 outb(0, dev->iobase + DAS16_CNTR_CONTROL);
725 static int das16_ai_rinsn(struct comedi_device *dev, struct comedi_subdevice *s,
726 struct comedi_insn *insn, unsigned int *data)
728 const struct das16_board *board = comedi_board(dev);
729 struct das16_private_struct *devpriv = dev->private;
735 /* disable interrupts and pacing */
736 devpriv->control_state &= ~DAS16_INTE & ~DMA_ENABLE & ~PACING_MASK;
737 outb(devpriv->control_state, dev->iobase + DAS16_CONTROL);
739 /* set multiplexer */
740 chan = CR_CHAN(insn->chanspec);
741 chan |= CR_CHAN(insn->chanspec) << 4;
742 outb(chan, dev->iobase + DAS16_MUX);
745 if (board->ai_pg != das16_pg_none) {
746 range = CR_RANGE(insn->chanspec);
747 outb((das16_gainlists[board->ai_pg])[range],
748 dev->iobase + DAS16_GAIN);
751 for (n = 0; n < insn->n; n++) {
752 /* trigger conversion */
753 outb_p(0, dev->iobase + DAS16_TRIG);
755 for (i = 0; i < DAS16_TIMEOUT; i++) {
756 if (!(inb(dev->iobase + DAS16_STATUS) & BUSY))
759 if (i == DAS16_TIMEOUT) {
760 printk("das16: timeout\n");
763 msb = inb(dev->iobase + DAS16_AI_MSB);
764 lsb = inb(dev->iobase + DAS16_AI_LSB);
765 if (board->ai_nbits == 12)
766 data[n] = ((lsb >> 4) & 0xf) | (msb << 4);
768 data[n] = lsb | (msb << 8);
775 static int das16_di_rbits(struct comedi_device *dev, struct comedi_subdevice *s,
776 struct comedi_insn *insn, unsigned int *data)
780 bits = inb(dev->iobase + DAS16_DIO) & 0xf;
787 static int das16_do_wbits(struct comedi_device *dev, struct comedi_subdevice *s,
788 struct comedi_insn *insn, unsigned int *data)
792 /* only set bits that have been masked */
795 /* zero bits that have been masked */
797 /* set masked bits */
798 wbits |= data[0] & data[1];
802 outb(s->state, dev->iobase + DAS16_DIO);
807 static int das16_ao_winsn(struct comedi_device *dev, struct comedi_subdevice *s,
808 struct comedi_insn *insn, unsigned int *data)
810 const struct das16_board *board = comedi_board(dev);
815 chan = CR_CHAN(insn->chanspec);
817 for (i = 0; i < insn->n; i++) {
818 if (board->ao_nbits == 12) {
819 lsb = (data[i] << 4) & 0xff;
820 msb = (data[i] >> 4) & 0xff;
822 lsb = data[i] & 0xff;
823 msb = (data[i] >> 8) & 0xff;
825 outb(lsb, dev->iobase + DAS16_AO_LSB(chan));
826 outb(msb, dev->iobase + DAS16_AO_MSB(chan));
832 /* the pc104-das16jr (at least) has problems if the dma
833 transfer is interrupted in the middle of transferring
834 a 16 bit sample, so this function takes care to get
835 an even transfer count after disabling dma
838 static int disable_dma_on_even(struct comedi_device *dev)
840 struct das16_private_struct *devpriv = dev->private;
843 static const int disable_limit = 100;
844 static const int enable_timeout = 100;
846 disable_dma(devpriv->dma_chan);
847 residue = get_dma_residue(devpriv->dma_chan);
848 for (i = 0; i < disable_limit && (residue % 2); ++i) {
850 enable_dma(devpriv->dma_chan);
851 for (j = 0; j < enable_timeout; ++j) {
854 new_residue = get_dma_residue(devpriv->dma_chan);
855 if (new_residue != residue)
858 disable_dma(devpriv->dma_chan);
859 residue = get_dma_residue(devpriv->dma_chan);
861 if (i == disable_limit) {
862 comedi_error(dev, "failed to get an even dma transfer, "
863 "could be trouble.");
868 static void das16_interrupt(struct comedi_device *dev)
870 const struct das16_board *board = comedi_board(dev);
871 struct das16_private_struct *devpriv = dev->private;
872 unsigned long dma_flags, spin_flags;
873 struct comedi_subdevice *s = dev->read_subdev;
874 struct comedi_async *async;
875 struct comedi_cmd *cmd;
876 int num_bytes, residue;
879 if (dev->attached == 0) {
880 comedi_error(dev, "premature interrupt");
883 /* initialize async here to make sure it is not NULL */
887 if (devpriv->dma_chan == 0) {
888 comedi_error(dev, "interrupt with no dma channel?");
892 spin_lock_irqsave(&dev->spinlock, spin_flags);
893 if ((devpriv->control_state & DMA_ENABLE) == 0) {
894 spin_unlock_irqrestore(&dev->spinlock, spin_flags);
895 DEBUG_PRINT("interrupt while dma disabled?\n");
899 dma_flags = claim_dma_lock();
900 clear_dma_ff(devpriv->dma_chan);
901 residue = disable_dma_on_even(dev);
903 /* figure out how many points to read */
904 if (residue > devpriv->dma_transfer_size) {
905 comedi_error(dev, "residue > transfer size!\n");
906 async->events |= COMEDI_CB_ERROR | COMEDI_CB_EOA;
909 num_bytes = devpriv->dma_transfer_size - residue;
911 if (cmd->stop_src == TRIG_COUNT &&
912 num_bytes >= devpriv->adc_byte_count) {
913 num_bytes = devpriv->adc_byte_count;
914 async->events |= COMEDI_CB_EOA;
917 buffer_index = devpriv->current_buffer;
918 devpriv->current_buffer = (devpriv->current_buffer + 1) % 2;
919 devpriv->adc_byte_count -= num_bytes;
921 /* figure out how many bytes for next transfer */
922 if (cmd->stop_src == TRIG_COUNT && devpriv->timer_mode == 0 &&
923 devpriv->dma_transfer_size > devpriv->adc_byte_count)
924 devpriv->dma_transfer_size = devpriv->adc_byte_count;
927 if ((async->events & COMEDI_CB_EOA) == 0) {
928 set_dma_addr(devpriv->dma_chan,
929 devpriv->dma_buffer_addr[devpriv->current_buffer]);
930 set_dma_count(devpriv->dma_chan, devpriv->dma_transfer_size);
931 enable_dma(devpriv->dma_chan);
932 /* reenable conversions for das1600 mode, (stupid hardware) */
933 if (board->size > 0x400 && devpriv->timer_mode == 0)
934 outb(0x00, dev->iobase + DAS1600_CONV);
937 release_dma_lock(dma_flags);
939 spin_unlock_irqrestore(&dev->spinlock, spin_flags);
941 cfc_write_array_to_buffer(s,
942 devpriv->dma_buffer[buffer_index], num_bytes);
944 cfc_handle_events(dev, s);
947 static irqreturn_t das16_dma_interrupt(int irq, void *d)
950 struct comedi_device *dev = d;
952 status = inb(dev->iobase + DAS16_STATUS);
954 if ((status & DAS16_INT) == 0) {
955 DEBUG_PRINT("spurious interrupt\n");
959 /* clear interrupt */
960 outb(0x00, dev->iobase + DAS16_STATUS);
961 das16_interrupt(dev);
965 static void das16_timer_interrupt(unsigned long arg)
967 struct comedi_device *dev = (struct comedi_device *)arg;
968 struct das16_private_struct *devpriv = dev->private;
970 das16_interrupt(dev);
972 if (devpriv->timer_running)
973 mod_timer(&devpriv->timer, jiffies + timer_period());
976 static void reg_dump(struct comedi_device *dev)
978 DEBUG_PRINT("********DAS1600 REGISTER DUMP********\n");
979 DEBUG_PRINT("DAS16_MUX: %x\n", inb(dev->iobase + DAS16_MUX));
980 DEBUG_PRINT("DAS16_DIO: %x\n", inb(dev->iobase + DAS16_DIO));
981 DEBUG_PRINT("DAS16_STATUS: %x\n", inb(dev->iobase + DAS16_STATUS));
982 DEBUG_PRINT("DAS16_CONTROL: %x\n", inb(dev->iobase + DAS16_CONTROL));
983 DEBUG_PRINT("DAS16_PACER: %x\n", inb(dev->iobase + DAS16_PACER));
984 DEBUG_PRINT("DAS16_GAIN: %x\n", inb(dev->iobase + DAS16_GAIN));
985 DEBUG_PRINT("DAS16_CNTR_CONTROL: %x\n",
986 inb(dev->iobase + DAS16_CNTR_CONTROL));
987 DEBUG_PRINT("DAS1600_CONV: %x\n", inb(dev->iobase + DAS1600_CONV));
988 DEBUG_PRINT("DAS1600_BURST: %x\n", inb(dev->iobase + DAS1600_BURST));
989 DEBUG_PRINT("DAS1600_ENABLE: %x\n", inb(dev->iobase + DAS1600_ENABLE));
990 DEBUG_PRINT("DAS1600_STATUS_B: %x\n",
991 inb(dev->iobase + DAS1600_STATUS_B));
994 static int das16_probe(struct comedi_device *dev, struct comedi_devconfig *it)
996 const struct das16_board *board = comedi_board(dev);
997 struct das16_private_struct *devpriv = dev->private;
1001 /* status is available on all boards */
1003 status = inb(dev->iobase + DAS16_STATUS);
1005 if ((status & UNIPOLAR))
1006 devpriv->ai_unipolar = 1;
1008 devpriv->ai_unipolar = 0;
1011 if ((status & DAS16_MUXBIT))
1012 devpriv->ai_singleended = 1;
1014 devpriv->ai_singleended = 0;
1017 /* diobits indicates boards */
1019 diobits = inb(dev->iobase + DAS16_DIO) & 0xf0;
1021 printk(KERN_INFO " id bits are 0x%02x\n", diobits);
1022 if (board->id != diobits) {
1023 printk(KERN_INFO " requested board's id bits are 0x%x (ignore)\n",
1030 static int das1600_mode_detect(struct comedi_device *dev)
1032 struct das16_private_struct *devpriv = dev->private;
1035 status = inb(dev->iobase + DAS1600_STATUS_B);
1037 if (status & DAS1600_CLK_10MHZ) {
1038 devpriv->clockbase = 100;
1039 printk(KERN_INFO " 10MHz pacer clock\n");
1041 devpriv->clockbase = 1000;
1042 printk(KERN_INFO " 1MHz pacer clock\n");
1050 static void das16_ai_munge(struct comedi_device *dev,
1051 struct comedi_subdevice *s, void *array,
1052 unsigned int num_bytes,
1053 unsigned int start_chan_index)
1055 const struct das16_board *board = comedi_board(dev);
1056 unsigned int i, num_samples = num_bytes / sizeof(short);
1057 short *data = array;
1059 for (i = 0; i < num_samples; i++) {
1060 data[i] = le16_to_cpu(data[i]);
1061 if (board->ai_nbits == 12)
1062 data[i] = (data[i] >> 4) & 0xfff;
1073 * 3 Clock speed (in MHz)
1075 static int das16_attach(struct comedi_device *dev, struct comedi_devconfig *it)
1077 const struct das16_board *board = comedi_board(dev);
1078 struct das16_private_struct *devpriv;
1079 struct comedi_subdevice *s;
1082 unsigned long iobase;
1083 unsigned int dma_chan;
1085 unsigned long flags;
1086 struct comedi_krange *user_ai_range, *user_ao_range;
1088 iobase = it->options[0];
1090 irq = it->options[1];
1091 timer_mode = it->options[8];
1093 /* always use time_mode since using irq can drop samples while
1094 * waiting for dma done interrupt (due to hardware limitations) */
1100 printk(KERN_INFO "comedi%d: das16:", dev->minor);
1102 /* check that clock setting is valid */
1103 if (it->options[3]) {
1104 if (it->options[3] != 0 &&
1105 it->options[3] != 1 && it->options[3] != 10) {
1107 ("\n Invalid option. Master clock must be set "
1108 "to 1 or 10 (MHz)\n");
1113 devpriv = kzalloc(sizeof(*devpriv), GFP_KERNEL);
1116 dev->private = devpriv;
1118 if (board->size < 0x400) {
1119 printk(" 0x%04lx-0x%04lx\n", iobase, iobase + board->size);
1120 if (!request_region(iobase, board->size, "das16")) {
1121 printk(KERN_ERR " I/O port conflict\n");
1125 printk(KERN_INFO " 0x%04lx-0x%04lx 0x%04lx-0x%04lx\n",
1126 iobase, iobase + 0x0f,
1128 iobase + 0x400 + (board->size & 0x3ff));
1129 if (!request_region(iobase, 0x10, "das16")) {
1130 printk(KERN_ERR " I/O port conflict: 0x%04lx-0x%04lx\n",
1131 iobase, iobase + 0x0f);
1134 if (!request_region(iobase + 0x400, board->size & 0x3ff,
1136 release_region(iobase, 0x10);
1137 printk(KERN_ERR " I/O port conflict: 0x%04lx-0x%04lx\n",
1139 iobase + 0x400 + (board->size & 0x3ff));
1144 dev->iobase = iobase;
1146 /* probe id bits to make sure they are consistent */
1147 if (das16_probe(dev, it)) {
1148 printk(KERN_ERR " id bits do not match selected board, aborting\n");
1151 dev->board_name = board->name;
1153 /* get master clock speed */
1154 if (board->size < 0x400) {
1156 devpriv->clockbase = 1000 / it->options[3];
1158 devpriv->clockbase = 1000; /* 1 MHz default */
1160 das1600_mode_detect(dev);
1163 /* now for the irq */
1164 if (irq > 1 && irq < 8) {
1165 ret = request_irq(irq, das16_dma_interrupt, 0, "das16", dev);
1170 printk(KERN_INFO " ( irq = %u )", irq);
1171 } else if (irq == 0) {
1172 printk(" ( no irq )");
1174 printk(" invalid irq\n");
1178 /* initialize dma */
1179 dma_chan = it->options[2];
1180 if (dma_chan == 1 || dma_chan == 3) {
1181 /* allocate dma buffers */
1183 for (i = 0; i < 2; i++) {
1184 devpriv->dma_buffer[i] = pci_alloc_consistent(
1185 NULL, DAS16_DMA_SIZE,
1186 &devpriv->dma_buffer_addr[i]);
1188 if (devpriv->dma_buffer[i] == NULL)
1191 if (request_dma(dma_chan, "das16")) {
1192 printk(KERN_ERR " failed to allocate dma channel %i\n",
1196 devpriv->dma_chan = dma_chan;
1197 flags = claim_dma_lock();
1198 disable_dma(devpriv->dma_chan);
1199 set_dma_mode(devpriv->dma_chan, DMA_MODE_READ);
1200 release_dma_lock(flags);
1201 printk(KERN_INFO " ( dma = %u)\n", dma_chan);
1202 } else if (dma_chan == 0) {
1203 printk(KERN_INFO " ( no dma )\n");
1205 printk(KERN_ERR " invalid dma channel\n");
1209 /* get any user-defined input range */
1210 if (board->ai_pg == das16_pg_none &&
1211 (it->options[4] || it->options[5])) {
1212 /* allocate single-range range table */
1213 devpriv->user_ai_range_table =
1214 kmalloc(sizeof(struct comedi_lrange) +
1215 sizeof(struct comedi_krange), GFP_KERNEL);
1216 /* initialize ai range */
1217 devpriv->user_ai_range_table->length = 1;
1218 user_ai_range = devpriv->user_ai_range_table->range;
1219 user_ai_range->min = it->options[4];
1220 user_ai_range->max = it->options[5];
1221 user_ai_range->flags = UNIT_volt;
1223 /* get any user-defined output range */
1224 if (it->options[6] || it->options[7]) {
1225 /* allocate single-range range table */
1226 devpriv->user_ao_range_table =
1227 kmalloc(sizeof(struct comedi_lrange) +
1228 sizeof(struct comedi_krange), GFP_KERNEL);
1229 /* initialize ao range */
1230 devpriv->user_ao_range_table->length = 1;
1231 user_ao_range = devpriv->user_ao_range_table->range;
1232 user_ao_range->min = it->options[6];
1233 user_ao_range->max = it->options[7];
1234 user_ao_range->flags = UNIT_volt;
1238 init_timer(&(devpriv->timer));
1239 devpriv->timer.function = das16_timer_interrupt;
1240 devpriv->timer.data = (unsigned long)dev;
1242 devpriv->timer_mode = timer_mode ? 1 : 0;
1244 ret = comedi_alloc_subdevices(dev, 5);
1248 s = &dev->subdevices[0];
1249 dev->read_subdev = s;
1252 s->type = COMEDI_SUBD_AI;
1253 s->subdev_flags = SDF_READABLE | SDF_CMD_READ;
1254 if (devpriv->ai_singleended) {
1256 s->len_chanlist = 16;
1257 s->subdev_flags |= SDF_GROUND;
1260 s->len_chanlist = 8;
1261 s->subdev_flags |= SDF_DIFF;
1263 s->maxdata = (1 << board->ai_nbits) - 1;
1264 if (devpriv->user_ai_range_table) { /* user defined ai range */
1265 s->range_table = devpriv->user_ai_range_table;
1266 } else if (devpriv->ai_unipolar) {
1267 s->range_table = das16_ai_uni_lranges[board->ai_pg];
1269 s->range_table = das16_ai_bip_lranges[board->ai_pg];
1271 s->insn_read = board->ai;
1272 s->do_cmdtest = das16_cmd_test;
1273 s->do_cmd = das16_cmd_exec;
1274 s->cancel = das16_cancel;
1275 s->munge = das16_ai_munge;
1277 s->type = COMEDI_SUBD_UNUSED;
1280 s = &dev->subdevices[1];
1283 s->type = COMEDI_SUBD_AO;
1284 s->subdev_flags = SDF_WRITABLE;
1286 s->maxdata = (1 << board->ao_nbits) - 1;
1287 /* user defined ao range */
1288 if (devpriv->user_ao_range_table)
1289 s->range_table = devpriv->user_ao_range_table;
1291 s->range_table = &range_unknown;
1293 s->insn_write = board->ao;
1295 s->type = COMEDI_SUBD_UNUSED;
1298 s = &dev->subdevices[2];
1301 s->type = COMEDI_SUBD_DI;
1302 s->subdev_flags = SDF_READABLE;
1305 s->range_table = &range_digital;
1306 s->insn_bits = board->di;
1308 s->type = COMEDI_SUBD_UNUSED;
1311 s = &dev->subdevices[3];
1314 s->type = COMEDI_SUBD_DO;
1315 s->subdev_flags = SDF_WRITABLE | SDF_READABLE;
1318 s->range_table = &range_digital;
1319 s->insn_bits = board->do_;
1320 /* initialize digital output lines */
1321 outb(s->state, dev->iobase + DAS16_DIO);
1323 s->type = COMEDI_SUBD_UNUSED;
1326 s = &dev->subdevices[4];
1328 if (board->i8255_offset != 0) {
1329 subdev_8255_init(dev, s, NULL, (dev->iobase +
1330 board->i8255_offset));
1332 s->type = COMEDI_SUBD_UNUSED;
1336 /* set the interrupt level */
1337 devpriv->control_state = DAS16_IRQ(dev->irq);
1338 outb(devpriv->control_state, dev->iobase + DAS16_CONTROL);
1340 /* turn on das1600 mode if available */
1341 if (board->size > 0x400) {
1342 outb(DAS1600_ENABLE_VAL, dev->iobase + DAS1600_ENABLE);
1343 outb(0, dev->iobase + DAS1600_CONV);
1344 outb(0, dev->iobase + DAS1600_BURST);
1350 static void das16_detach(struct comedi_device *dev)
1352 const struct das16_board *board = comedi_board(dev);
1353 struct das16_private_struct *devpriv = dev->private;
1356 if (dev->subdevices)
1357 subdev_8255_cleanup(dev, &dev->subdevices[4]);
1360 for (i = 0; i < 2; i++) {
1361 if (devpriv->dma_buffer[i])
1362 pci_free_consistent(NULL, DAS16_DMA_SIZE,
1363 devpriv->dma_buffer[i],
1365 dma_buffer_addr[i]);
1367 if (devpriv->dma_chan)
1368 free_dma(devpriv->dma_chan);
1369 kfree(devpriv->user_ai_range_table);
1370 kfree(devpriv->user_ao_range_table);
1373 free_irq(dev->irq, dev);
1375 if (board->size < 0x400) {
1376 release_region(dev->iobase, board->size);
1378 release_region(dev->iobase, 0x10);
1379 release_region(dev->iobase + 0x400,
1380 board->size & 0x3ff);
1385 static const struct das16_board das16_boards[] = {
1388 .ai = das16_ai_rinsn,
1391 .ai_pg = das16_pg_none,
1392 .ao = das16_ao_winsn,
1394 .di = das16_di_rbits,
1395 .do_ = das16_do_wbits,
1396 .i8255_offset = 0x10,
1397 .i8254_offset = 0x0c,
1402 .ai = das16_ai_rinsn,
1405 .ai_pg = das16_pg_none,
1406 .ao = das16_ao_winsn,
1408 .di = das16_di_rbits,
1409 .do_ = das16_do_wbits,
1410 .i8255_offset = 0x10,
1411 .i8254_offset = 0x0c,
1416 .ai = das16_ai_rinsn,
1419 .ai_pg = das16_pg_none,
1420 .ao = das16_ao_winsn,
1422 .di = das16_di_rbits,
1423 .do_ = das16_do_wbits,
1424 .i8255_offset = 0x10,
1425 .i8254_offset = 0x0c,
1429 .name = "cio-das16",
1430 .ai = das16_ai_rinsn,
1433 .ai_pg = das16_pg_none,
1434 .ao = das16_ao_winsn,
1436 .di = das16_di_rbits,
1437 .do_ = das16_do_wbits,
1438 .i8255_offset = 0x10,
1439 .i8254_offset = 0x0c,
1443 .name = "cio-das16/f",
1444 .ai = das16_ai_rinsn,
1447 .ai_pg = das16_pg_none,
1448 .ao = das16_ao_winsn,
1450 .di = das16_di_rbits,
1451 .do_ = das16_do_wbits,
1452 .i8255_offset = 0x10,
1453 .i8254_offset = 0x0c,
1457 .name = "cio-das16/jr",
1458 .ai = das16_ai_rinsn,
1461 .ai_pg = das16_pg_16jr,
1463 .di = das16_di_rbits,
1464 .do_ = das16_do_wbits,
1466 .i8254_offset = 0x0c,
1470 .name = "pc104-das16jr",
1471 .ai = das16_ai_rinsn,
1474 .ai_pg = das16_pg_16jr,
1476 .di = das16_di_rbits,
1477 .do_ = das16_do_wbits,
1479 .i8254_offset = 0x0c,
1483 .name = "cio-das16jr/16",
1484 .ai = das16_ai_rinsn,
1487 .ai_pg = das16_pg_16jr_16,
1489 .di = das16_di_rbits,
1490 .do_ = das16_do_wbits,
1492 .i8254_offset = 0x0c,
1496 .name = "pc104-das16jr/16",
1497 .ai = das16_ai_rinsn,
1500 .ai_pg = das16_pg_16jr_16,
1502 .di = das16_di_rbits,
1503 .do_ = das16_do_wbits,
1505 .i8254_offset = 0x0c,
1510 .ai = das16_ai_rinsn,
1513 .ai_pg = das16_pg_none,
1515 .di = das16_di_rbits,
1516 .do_ = das16_do_wbits,
1517 .i8255_offset = 0x400,
1518 .i8254_offset = 0x0c,
1523 .ai = das16_ai_rinsn,
1526 .ai_pg = das16_pg_none,
1528 .di = das16_di_rbits,
1529 .do_ = das16_do_wbits,
1530 .i8255_offset = 0x400,
1531 .i8254_offset = 0x0c,
1536 .ai = das16_ai_rinsn,
1539 .ai_pg = das16_pg_1601,
1541 .di = das16_di_rbits,
1542 .do_ = das16_do_wbits,
1543 .i8255_offset = 0x0,
1544 .i8254_offset = 0x0c,
1549 .ai = das16_ai_rinsn,
1552 .ai_pg = das16_pg_1602,
1554 .di = das16_di_rbits,
1555 .do_ = das16_do_wbits,
1556 .i8255_offset = 0x0,
1557 .i8254_offset = 0x0c,
1562 .ai = das16_ai_rinsn,
1565 .ai_pg = das16_pg_1601,
1566 .ao = das16_ao_winsn,
1568 .di = das16_di_rbits,
1569 .do_ = das16_do_wbits,
1570 .i8255_offset = 0x400,
1571 .i8254_offset = 0x0c,
1576 .ai = das16_ai_rinsn,
1579 .ai_pg = das16_pg_1602,
1580 .ao = das16_ao_winsn,
1582 .di = das16_di_rbits,
1583 .do_ = das16_do_wbits,
1584 .i8255_offset = 0x400,
1585 .i8254_offset = 0x0c,
1589 .name = "cio-das1401/12",
1590 .ai = das16_ai_rinsn,
1593 .ai_pg = das16_pg_1601,
1595 .di = das16_di_rbits,
1596 .do_ = das16_do_wbits,
1598 .i8254_offset = 0x0c,
1602 .name = "cio-das1402/12",
1603 .ai = das16_ai_rinsn,
1606 .ai_pg = das16_pg_1602,
1608 .di = das16_di_rbits,
1609 .do_ = das16_do_wbits,
1611 .i8254_offset = 0x0c,
1615 .name = "cio-das1402/16",
1616 .ai = das16_ai_rinsn,
1619 .ai_pg = das16_pg_1602,
1621 .di = das16_di_rbits,
1622 .do_ = das16_do_wbits,
1624 .i8254_offset = 0x0c,
1628 .name = "cio-das1601/12",
1629 .ai = das16_ai_rinsn,
1632 .ai_pg = das16_pg_1601,
1633 .ao = das16_ao_winsn,
1635 .di = das16_di_rbits,
1636 .do_ = das16_do_wbits,
1637 .i8255_offset = 0x400,
1638 .i8254_offset = 0x0c,
1642 .name = "cio-das1602/12",
1643 .ai = das16_ai_rinsn,
1646 .ai_pg = das16_pg_1602,
1647 .ao = das16_ao_winsn,
1649 .di = das16_di_rbits,
1650 .do_ = das16_do_wbits,
1651 .i8255_offset = 0x400,
1652 .i8254_offset = 0x0c,
1656 .name = "cio-das1602/16",
1657 .ai = das16_ai_rinsn,
1660 .ai_pg = das16_pg_1602,
1661 .ao = das16_ao_winsn,
1663 .di = das16_di_rbits,
1664 .do_ = das16_do_wbits,
1665 .i8255_offset = 0x400,
1666 .i8254_offset = 0x0c,
1670 .name = "cio-das16/330",
1671 .ai = das16_ai_rinsn,
1674 .ai_pg = das16_pg_16jr,
1676 .di = das16_di_rbits,
1677 .do_ = das16_do_wbits,
1679 .i8254_offset = 0x0c,
1685 static struct comedi_driver das16_driver = {
1686 .driver_name = "das16",
1687 .module = THIS_MODULE,
1688 .attach = das16_attach,
1689 .detach = das16_detach,
1690 .board_name = &das16_boards[0].name,
1691 .num_names = ARRAY_SIZE(das16_boards),
1692 .offset = sizeof(das16_boards[0]),
1694 module_comedi_driver(das16_driver);
1696 MODULE_AUTHOR("Comedi http://www.comedi.org");
1697 MODULE_DESCRIPTION("Comedi low-level driver");
1698 MODULE_LICENSE("GPL");