1 // SPDX-License-Identifier: GPL-2.0+
3 * Comedi driver for Keithley DAS-1700/DAS-1800 series boards
4 * Copyright (C) 2000 Frank Mori Hess <fmhess@users.sourceforge.net>
6 * COMEDI - Linux Control and Measurement Device Interface
7 * Copyright (C) 2000 David A. Schleef <ds@schleef.org>
12 * Description: Keithley Metrabyte DAS1800 (& compatibles)
13 * Author: Frank Mori Hess <fmhess@users.sourceforge.net>
14 * Devices: [Keithley Metrabyte] DAS-1701ST (das-1701st),
15 * DAS-1701ST-DA (das-1701st-da), DAS-1701/AO (das-1701ao),
16 * DAS-1702ST (das-1702st), DAS-1702ST-DA (das-1702st-da),
17 * DAS-1702HR (das-1702hr), DAS-1702HR-DA (das-1702hr-da),
18 * DAS-1702/AO (das-1702ao), DAS-1801ST (das-1801st),
19 * DAS-1801ST-DA (das-1801st-da), DAS-1801HC (das-1801hc),
20 * DAS-1801AO (das-1801ao), DAS-1802ST (das-1802st),
21 * DAS-1802ST-DA (das-1802st-da), DAS-1802HR (das-1802hr),
22 * DAS-1802HR-DA (das-1802hr-da), DAS-1802HC (das-1802hc),
23 * DAS-1802AO (das-1802ao)
26 * Configuration options:
27 * [0] - I/O port base address
28 * [1] - IRQ (optional, required for analog input cmd support)
29 * [2] - DMA0 (optional, requires irq)
30 * [3] - DMA1 (optional, requires irq and dma0)
32 * analog input cmd triggers supported:
34 * start_src TRIG_NOW command starts immediately
35 * TRIG_EXT command starts on external pin TGIN
37 * scan_begin_src TRIG_FOLLOW paced/external scans start immediately
38 * TRIG_TIMER burst scans start periodically
39 * TRIG_EXT burst scans start on external pin XPCLK
41 * scan_end_src TRIG_COUNT scan ends after last channel
43 * convert_src TRIG_TIMER paced/burst conversions are timed
44 * TRIG_EXT conversions on external pin XPCLK
45 * (requires scan_begin_src == TRIG_FOLLOW)
47 * stop_src TRIG_COUNT command stops after stop_arg scans
48 * TRIG_EXT command stops on external pin TGIN
49 * TRIG_NONE command runs until canceled
51 * If TRIG_EXT is used for both the start_src and stop_src, the first TGIN
52 * trigger starts the command, and the second trigger will stop it. If only
53 * one is TRIG_EXT, the first trigger will either stop or start the command.
54 * The external pin TGIN is normally set for negative edge triggering. It
55 * can be set to positive edge with the CR_INVERT flag. If TRIG_EXT is used
56 * for both the start_src and stop_src they must have the same polarity.
58 * Minimum conversion speed is limited to 64 microseconds (convert_arg <= 64000)
59 * for 'burst' scans. This limitation does not apply for 'paced' scans. The
60 * maximum conversion speed is limited by the board (convert_arg >= ai_speed).
61 * Maximum conversion speeds are not always achievable depending on the
62 * board setup (see user manual).
65 * Only the DAS-1801ST has been tested by me.
66 * Unipolar and bipolar ranges cannot be mixed in the channel/gain list.
68 * The waveform analog output on the 'ao' cards is not supported.
69 * If you need it, send me (Frank Hess) an email.
72 #include <linux/module.h>
73 #include <linux/interrupt.h>
74 #include <linux/slab.h>
77 #include "../comedidev.h"
79 #include "comedi_isadma.h"
80 #include "comedi_8254.h"
83 #define DAS1800_SIZE 16 /* uses 16 io addresses */
84 #define FIFO_SIZE 1024 /* 1024 sample fifo */
85 #define DMA_BUF_SIZE 0x1ff00 /* size in bytes of dma buffers */
87 /* Registers for the das1800 */
88 #define DAS1800_FIFO 0x0
89 #define DAS1800_QRAM 0x0
90 #define DAS1800_DAC 0x0
91 #define DAS1800_SELECT 0x2
94 #define DAC(a) (0x2 + a)
95 #define DAS1800_DIGITAL 0x3
96 #define DAS1800_CONTROL_A 0x4
104 #define DAS1800_CONTROL_B 0x5
108 #define DMA_CH5_CH6 0x5
109 #define DMA_CH6_CH7 0x6
110 #define DMA_CH7_CH5 0x7
111 #define DMA_ENABLED 0x3
120 #define DAS1800_CONTROL_C 0X6
128 #define DAS1800_STATUS 0x7
136 #define CVEN_MASK 0x40
137 #define CLEAR_INTR_MASK (CVEN_MASK | 0x1f)
138 #define DAS1800_BURST_LENGTH 0x8
139 #define DAS1800_BURST_RATE 0x9
140 #define DAS1800_QRAM_ADDRESS 0xa
141 #define DAS1800_COUNTER 0xc
143 #define IOBASE2 0x400
145 static const struct comedi_lrange das1801_ai_range = {
147 BIP_RANGE(5), /* bipolar gain = 1 */
148 BIP_RANGE(1), /* bipolar gain = 10 */
149 BIP_RANGE(0.1), /* bipolar gain = 50 */
150 BIP_RANGE(0.02), /* bipolar gain = 250 */
151 UNI_RANGE(5), /* unipolar gain = 1 */
152 UNI_RANGE(1), /* unipolar gain = 10 */
153 UNI_RANGE(0.1), /* unipolar gain = 50 */
154 UNI_RANGE(0.02) /* unipolar gain = 250 */
158 static const struct comedi_lrange das1802_ai_range = {
160 BIP_RANGE(10), /* bipolar gain = 1 */
161 BIP_RANGE(5), /* bipolar gain = 2 */
162 BIP_RANGE(2.5), /* bipolar gain = 4 */
163 BIP_RANGE(1.25), /* bipolar gain = 8 */
164 UNI_RANGE(10), /* unipolar gain = 1 */
165 UNI_RANGE(5), /* unipolar gain = 2 */
166 UNI_RANGE(2.5), /* unipolar gain = 4 */
167 UNI_RANGE(1.25) /* unipolar gain = 8 */
172 * The waveform analog outputs on the 'ao' boards are not currently
173 * supported. They have a comedi_lrange of:
174 * { 2, { BIP_RANGE(10), BIP_RANGE(5) } }
177 enum das1800_boardid {
198 /* board probe id values (hi byte of the digital input register) */
199 #define DAS1800_ID_ST_DA 0x3
200 #define DAS1800_ID_HR_DA 0x4
201 #define DAS1800_ID_AO 0x5
202 #define DAS1800_ID_HR 0x6
203 #define DAS1800_ID_ST 0x7
204 #define DAS1800_ID_HC 0x8
206 struct das1800_board {
209 unsigned int ai_speed;
210 unsigned int is_01_series:1;
213 static const struct das1800_board das1800_boards[] = {
214 [BOARD_DAS1701ST] = {
215 .name = "das-1701st",
220 [BOARD_DAS1701ST_DA] = {
221 .name = "das-1701st-da",
222 .id = DAS1800_ID_ST_DA,
226 [BOARD_DAS1702ST] = {
227 .name = "das-1702st",
231 [BOARD_DAS1702ST_DA] = {
232 .name = "das-1702st-da",
233 .id = DAS1800_ID_ST_DA,
236 [BOARD_DAS1702HR] = {
237 .name = "das-1702hr",
241 [BOARD_DAS1702HR_DA] = {
242 .name = "das-1702hr-da",
243 .id = DAS1800_ID_HR_DA,
246 [BOARD_DAS1701AO] = {
247 .name = "das-1701ao",
252 [BOARD_DAS1702AO] = {
253 .name = "das-1702ao",
257 [BOARD_DAS1801ST] = {
258 .name = "das-1801st",
263 [BOARD_DAS1801ST_DA] = {
264 .name = "das-1801st-da",
265 .id = DAS1800_ID_ST_DA,
269 [BOARD_DAS1802ST] = {
270 .name = "das-1802st",
274 [BOARD_DAS1802ST_DA] = {
275 .name = "das-1802st-da",
276 .id = DAS1800_ID_ST_DA,
279 [BOARD_DAS1802HR] = {
280 .name = "das-1802hr",
284 [BOARD_DAS1802HR_DA] = {
285 .name = "das-1802hr-da",
286 .id = DAS1800_ID_HR_DA,
289 [BOARD_DAS1801HC] = {
290 .name = "das-1801hc",
295 [BOARD_DAS1802HC] = {
296 .name = "das-1802hc",
300 [BOARD_DAS1801AO] = {
301 .name = "das-1801ao",
306 [BOARD_DAS1802AO] = {
307 .name = "das-1802ao",
313 struct das1800_private {
314 struct comedi_isadma *dma;
317 unsigned short *fifo_buf;
318 unsigned long iobase2;
322 static void das1800_ai_munge(struct comedi_device *dev,
323 struct comedi_subdevice *s,
324 void *data, unsigned int num_bytes,
325 unsigned int start_chan_index)
327 struct das1800_private *devpriv = dev->private;
328 unsigned short *array = data;
329 unsigned int num_samples = comedi_bytes_to_samples(s, num_bytes);
332 if (devpriv->ai_is_unipolar)
335 for (i = 0; i < num_samples; i++)
336 array[i] = comedi_offset_munge(s, array[i]);
339 static void das1800_handle_fifo_half_full(struct comedi_device *dev,
340 struct comedi_subdevice *s)
342 struct das1800_private *devpriv = dev->private;
343 unsigned int nsamples = comedi_nsamples_left(s, FIFO_SIZE / 2);
345 insw(dev->iobase + DAS1800_FIFO, devpriv->fifo_buf, nsamples);
346 comedi_buf_write_samples(s, devpriv->fifo_buf, nsamples);
349 static void das1800_handle_fifo_not_empty(struct comedi_device *dev,
350 struct comedi_subdevice *s)
352 struct comedi_cmd *cmd = &s->async->cmd;
355 while (inb(dev->iobase + DAS1800_STATUS) & FNE) {
356 dpnt = inw(dev->iobase + DAS1800_FIFO);
357 comedi_buf_write_samples(s, &dpnt, 1);
359 if (cmd->stop_src == TRIG_COUNT &&
360 s->async->scans_done >= cmd->stop_arg)
365 static void das1800_flush_dma_channel(struct comedi_device *dev,
366 struct comedi_subdevice *s,
367 struct comedi_isadma_desc *desc)
369 unsigned int residue = comedi_isadma_disable(desc->chan);
370 unsigned int nbytes = desc->size - residue;
371 unsigned int nsamples;
373 /* figure out how many points to read */
374 nsamples = comedi_bytes_to_samples(s, nbytes);
375 nsamples = comedi_nsamples_left(s, nsamples);
377 comedi_buf_write_samples(s, desc->virt_addr, nsamples);
380 static void das1800_flush_dma(struct comedi_device *dev,
381 struct comedi_subdevice *s)
383 struct das1800_private *devpriv = dev->private;
384 struct comedi_isadma *dma = devpriv->dma;
385 struct comedi_isadma_desc *desc = &dma->desc[dma->cur_dma];
386 const int dual_dma = devpriv->irq_dma_bits & DMA_DUAL;
388 das1800_flush_dma_channel(dev, s, desc);
391 /* switch to other channel and flush it */
392 dma->cur_dma = 1 - dma->cur_dma;
393 desc = &dma->desc[dma->cur_dma];
394 das1800_flush_dma_channel(dev, s, desc);
397 /* get any remaining samples in fifo */
398 das1800_handle_fifo_not_empty(dev, s);
401 static void das1800_handle_dma(struct comedi_device *dev,
402 struct comedi_subdevice *s, unsigned int status)
404 struct das1800_private *devpriv = dev->private;
405 struct comedi_isadma *dma = devpriv->dma;
406 struct comedi_isadma_desc *desc = &dma->desc[dma->cur_dma];
407 const int dual_dma = devpriv->irq_dma_bits & DMA_DUAL;
409 das1800_flush_dma_channel(dev, s, desc);
411 /* re-enable dma channel */
412 comedi_isadma_program(desc);
414 if (status & DMATC) {
415 /* clear DMATC interrupt bit */
416 outb(CLEAR_INTR_MASK & ~DMATC, dev->iobase + DAS1800_STATUS);
417 /* switch dma channels for next time, if appropriate */
419 dma->cur_dma = 1 - dma->cur_dma;
423 static int das1800_ai_cancel(struct comedi_device *dev,
424 struct comedi_subdevice *s)
426 struct das1800_private *devpriv = dev->private;
427 struct comedi_isadma *dma = devpriv->dma;
428 struct comedi_isadma_desc *desc;
431 /* disable and stop conversions */
432 outb(0x0, dev->iobase + DAS1800_STATUS);
433 outb(0x0, dev->iobase + DAS1800_CONTROL_B);
434 outb(0x0, dev->iobase + DAS1800_CONTROL_A);
437 for (i = 0; i < 2; i++) {
438 desc = &dma->desc[i];
440 comedi_isadma_disable(desc->chan);
447 static void das1800_ai_handler(struct comedi_device *dev)
449 struct das1800_private *devpriv = dev->private;
450 struct comedi_subdevice *s = dev->read_subdev;
451 struct comedi_async *async = s->async;
452 struct comedi_cmd *cmd = &async->cmd;
453 unsigned int status = inb(dev->iobase + DAS1800_STATUS);
455 /* select adc register (spinlock is already held) */
456 outb(ADC, dev->iobase + DAS1800_SELECT);
458 /* get samples with dma, fifo, or polled as necessary */
459 if (devpriv->irq_dma_bits & DMA_ENABLED)
460 das1800_handle_dma(dev, s, status);
461 else if (status & FHF)
462 das1800_handle_fifo_half_full(dev, s);
463 else if (status & FNE)
464 das1800_handle_fifo_not_empty(dev, s);
466 /* if the card's fifo has overflowed */
468 /* clear OVF interrupt bit */
469 outb(CLEAR_INTR_MASK & ~OVF, dev->iobase + DAS1800_STATUS);
470 dev_err(dev->class_dev, "FIFO overflow\n");
471 async->events |= COMEDI_CB_ERROR;
472 comedi_handle_events(dev, s);
475 /* stop taking data if appropriate */
476 /* stop_src TRIG_EXT */
477 if (status & CT0TC) {
478 /* clear CT0TC interrupt bit */
479 outb(CLEAR_INTR_MASK & ~CT0TC, dev->iobase + DAS1800_STATUS);
480 /* get all remaining samples before quitting */
481 if (devpriv->irq_dma_bits & DMA_ENABLED)
482 das1800_flush_dma(dev, s);
484 das1800_handle_fifo_not_empty(dev, s);
485 async->events |= COMEDI_CB_EOA;
486 } else if (cmd->stop_src == TRIG_COUNT &&
487 async->scans_done >= cmd->stop_arg) {
488 async->events |= COMEDI_CB_EOA;
491 comedi_handle_events(dev, s);
494 static int das1800_ai_poll(struct comedi_device *dev,
495 struct comedi_subdevice *s)
500 * Protects the indirect addressing selected by DAS1800_SELECT
501 * in das1800_ai_handler() also prevents race with das1800_interrupt().
503 spin_lock_irqsave(&dev->spinlock, flags);
505 das1800_ai_handler(dev);
507 spin_unlock_irqrestore(&dev->spinlock, flags);
509 return comedi_buf_n_bytes_ready(s);
512 static irqreturn_t das1800_interrupt(int irq, void *d)
514 struct comedi_device *dev = d;
517 if (!dev->attached) {
518 dev_err(dev->class_dev, "premature interrupt\n");
523 * Protects the indirect addressing selected by DAS1800_SELECT
524 * in das1800_ai_handler() also prevents race with das1800_ai_poll().
526 spin_lock(&dev->spinlock);
528 status = inb(dev->iobase + DAS1800_STATUS);
530 /* if interrupt was not caused by das-1800 */
531 if (!(status & INT)) {
532 spin_unlock(&dev->spinlock);
535 /* clear the interrupt status bit INT */
536 outb(CLEAR_INTR_MASK & ~INT, dev->iobase + DAS1800_STATUS);
537 /* handle interrupt */
538 das1800_ai_handler(dev);
540 spin_unlock(&dev->spinlock);
544 static int das1800_ai_fixup_paced_timing(struct comedi_device *dev,
545 struct comedi_cmd *cmd)
547 unsigned int arg = cmd->convert_arg;
551 * scan_begin_src is TRIG_FOLLOW
552 * convert_src is TRIG_TIMER
554 * The convert_arg sets the pacer sample acquisition time.
555 * The max acquisition speed is limited to the boards
556 * 'ai_speed' (this was already verified). The min speed is
557 * limited by the cascaded 8254 timer.
559 comedi_8254_cascade_ns_to_timer(dev->pacer, &arg, cmd->flags);
560 return comedi_check_trigger_arg_is(&cmd->convert_arg, arg);
563 static int das1800_ai_fixup_burst_timing(struct comedi_device *dev,
564 struct comedi_cmd *cmd)
566 unsigned int arg = cmd->convert_arg;
571 * scan_begin_src is TRIG_TIMER or TRIG_EXT
572 * convert_src is TRIG_TIMER
574 * The convert_arg sets burst sample acquisition time.
575 * The max acquisition speed is limited to the boards
576 * 'ai_speed' (this was already verified). The min speed is
577 * limiited to 64 microseconds,
579 err |= comedi_check_trigger_arg_max(&arg, 64000);
581 /* round to microseconds then verify */
582 switch (cmd->flags & CMDF_ROUND_MASK) {
583 case CMDF_ROUND_NEAREST:
585 arg = DIV_ROUND_CLOSEST(arg, 1000);
587 case CMDF_ROUND_DOWN:
591 arg = DIV_ROUND_UP(arg, 1000);
594 err |= comedi_check_trigger_arg_is(&cmd->convert_arg, arg * 1000);
597 * The pacer can be used to set the scan sample rate. The max scan
598 * speed is limited by the conversion speed and the number of channels
599 * to convert. The min speed is limited by the cascaded 8254 timer.
601 if (cmd->scan_begin_src == TRIG_TIMER) {
602 arg = cmd->convert_arg * cmd->chanlist_len;
603 err |= comedi_check_trigger_arg_min(&cmd->scan_begin_arg, arg);
605 arg = cmd->scan_begin_arg;
606 comedi_8254_cascade_ns_to_timer(dev->pacer, &arg, cmd->flags);
607 err |= comedi_check_trigger_arg_is(&cmd->scan_begin_arg, arg);
613 static int das1800_ai_check_chanlist(struct comedi_device *dev,
614 struct comedi_subdevice *s,
615 struct comedi_cmd *cmd)
617 unsigned int range = CR_RANGE(cmd->chanlist[0]);
618 bool unipolar0 = comedi_range_is_unipolar(s, range);
621 for (i = 1; i < cmd->chanlist_len; i++) {
622 range = CR_RANGE(cmd->chanlist[i]);
624 if (unipolar0 != comedi_range_is_unipolar(s, range)) {
625 dev_dbg(dev->class_dev,
626 "unipolar and bipolar ranges cannot be mixed in the chanlist\n");
634 static int das1800_ai_cmdtest(struct comedi_device *dev,
635 struct comedi_subdevice *s,
636 struct comedi_cmd *cmd)
638 const struct das1800_board *board = dev->board_ptr;
641 /* Step 1 : check if triggers are trivially valid */
643 err |= comedi_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_EXT);
644 err |= comedi_check_trigger_src(&cmd->scan_begin_src,
645 TRIG_FOLLOW | TRIG_TIMER | TRIG_EXT);
646 err |= comedi_check_trigger_src(&cmd->convert_src,
647 TRIG_TIMER | TRIG_EXT);
648 err |= comedi_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
649 err |= comedi_check_trigger_src(&cmd->stop_src,
650 TRIG_COUNT | TRIG_EXT | TRIG_NONE);
655 /* Step 2a : make sure trigger sources are unique */
657 err |= comedi_check_trigger_is_unique(cmd->start_src);
658 err |= comedi_check_trigger_is_unique(cmd->scan_begin_src);
659 err |= comedi_check_trigger_is_unique(cmd->convert_src);
660 err |= comedi_check_trigger_is_unique(cmd->stop_src);
662 /* Step 2b : and mutually compatible */
664 /* burst scans must use timed conversions */
665 if (cmd->scan_begin_src != TRIG_FOLLOW &&
666 cmd->convert_src != TRIG_TIMER)
669 /* the external pin TGIN must use the same polarity */
670 if (cmd->start_src == TRIG_EXT && cmd->stop_src == TRIG_EXT)
671 err |= comedi_check_trigger_arg_is(&cmd->start_arg,
677 /* Step 3: check if arguments are trivially valid */
679 if (cmd->start_arg == TRIG_NOW)
680 err |= comedi_check_trigger_arg_is(&cmd->start_arg, 0);
682 if (cmd->convert_src == TRIG_TIMER) {
683 err |= comedi_check_trigger_arg_min(&cmd->convert_arg,
687 err |= comedi_check_trigger_arg_min(&cmd->chanlist_len, 1);
688 err |= comedi_check_trigger_arg_is(&cmd->scan_end_arg,
691 switch (cmd->stop_src) {
693 err |= comedi_check_trigger_arg_min(&cmd->stop_arg, 1);
696 err |= comedi_check_trigger_arg_is(&cmd->stop_arg, 0);
705 /* Step 4: fix up any arguments */
707 if (cmd->convert_src == TRIG_TIMER) {
708 if (cmd->scan_begin_src == TRIG_FOLLOW)
709 err |= das1800_ai_fixup_paced_timing(dev, cmd);
710 else /* TRIG_TIMER or TRIG_EXT */
711 err |= das1800_ai_fixup_burst_timing(dev, cmd);
717 /* Step 5: check channel list if it exists */
718 if (cmd->chanlist && cmd->chanlist_len > 0)
719 err |= das1800_ai_check_chanlist(dev, s, cmd);
727 static unsigned char das1800_ai_chanspec_bits(struct comedi_subdevice *s,
728 unsigned int chanspec)
730 unsigned int range = CR_RANGE(chanspec);
731 unsigned int aref = CR_AREF(chanspec);
735 if (aref != AREF_DIFF)
737 if (aref == AREF_COMMON)
739 if (comedi_range_is_unipolar(s, range))
745 static unsigned int das1800_ai_transfer_size(struct comedi_device *dev,
746 struct comedi_subdevice *s,
747 unsigned int maxbytes,
750 struct comedi_cmd *cmd = &s->async->cmd;
751 unsigned int max_samples = comedi_bytes_to_samples(s, maxbytes);
752 unsigned int samples;
754 samples = max_samples;
756 /* for timed modes, make dma buffer fill in 'ns' time */
757 switch (cmd->scan_begin_src) {
758 case TRIG_FOLLOW: /* not in burst mode */
759 if (cmd->convert_src == TRIG_TIMER)
760 samples = ns / cmd->convert_arg;
763 samples = ns / (cmd->scan_begin_arg * cmd->chanlist_len);
767 /* limit samples to what is remaining in the command */
768 samples = comedi_nsamples_left(s, samples);
770 if (samples > max_samples)
771 samples = max_samples;
775 return comedi_samples_to_bytes(s, samples);
778 static void das1800_ai_setup_dma(struct comedi_device *dev,
779 struct comedi_subdevice *s)
781 struct das1800_private *devpriv = dev->private;
782 struct comedi_isadma *dma = devpriv->dma;
783 struct comedi_isadma_desc *desc;
786 if ((devpriv->irq_dma_bits & DMA_ENABLED) == 0)
790 desc = &dma->desc[0];
792 /* determine a dma transfer size to fill buffer in 0.3 sec */
793 bytes = das1800_ai_transfer_size(dev, s, desc->maxsize, 300000000);
796 comedi_isadma_program(desc);
798 /* set up dual dma if appropriate */
799 if (devpriv->irq_dma_bits & DMA_DUAL) {
800 desc = &dma->desc[1];
802 comedi_isadma_program(desc);
806 static void das1800_ai_set_chanlist(struct comedi_device *dev,
807 unsigned int *chanlist, unsigned int len)
812 /* protects the indirect addressing selected by DAS1800_SELECT */
813 spin_lock_irqsave(&dev->spinlock, flags);
815 /* select QRAM register and set start address */
816 outb(QRAM, dev->iobase + DAS1800_SELECT);
817 outb(len - 1, dev->iobase + DAS1800_QRAM_ADDRESS);
819 /* make channel / gain list */
820 for (i = 0; i < len; i++) {
821 unsigned int chan = CR_CHAN(chanlist[i]);
822 unsigned int range = CR_RANGE(chanlist[i]);
825 val = chan | ((range & 0x3) << 8);
826 outw(val, dev->iobase + DAS1800_QRAM);
829 /* finish write to QRAM */
830 outb(len - 1, dev->iobase + DAS1800_QRAM_ADDRESS);
832 spin_unlock_irqrestore(&dev->spinlock, flags);
835 static int das1800_ai_cmd(struct comedi_device *dev,
836 struct comedi_subdevice *s)
838 struct das1800_private *devpriv = dev->private;
839 int control_a, control_c;
840 struct comedi_async *async = s->async;
841 const struct comedi_cmd *cmd = &async->cmd;
842 unsigned int range0 = CR_RANGE(cmd->chanlist[0]);
845 * Disable dma on CMDF_WAKE_EOS, or CMDF_PRIORITY (because dma in
846 * handler is unsafe at hard real-time priority).
848 if (cmd->flags & (CMDF_WAKE_EOS | CMDF_PRIORITY))
849 devpriv->irq_dma_bits &= ~DMA_ENABLED;
851 devpriv->irq_dma_bits |= devpriv->dma_bits;
852 /* interrupt on end of conversion for CMDF_WAKE_EOS */
853 if (cmd->flags & CMDF_WAKE_EOS) {
854 /* interrupt fifo not empty */
855 devpriv->irq_dma_bits &= ~FIMD;
857 /* interrupt fifo half full */
858 devpriv->irq_dma_bits |= FIMD;
861 das1800_ai_cancel(dev, s);
863 devpriv->ai_is_unipolar = comedi_range_is_unipolar(s, range0);
866 if (cmd->stop_src == TRIG_EXT)
868 if (cmd->start_src == TRIG_EXT)
869 control_a |= TGEN | CGSL;
872 if (control_a & (ATEN | TGEN)) {
873 if ((cmd->start_arg & CR_INVERT) || (cmd->stop_arg & CR_INVERT))
877 control_c = das1800_ai_chanspec_bits(s, cmd->chanlist[0]);
878 /* set clock source to internal or external */
879 if (cmd->scan_begin_src == TRIG_FOLLOW) {
880 /* not in burst mode */
881 if (cmd->convert_src == TRIG_TIMER) {
882 /* trig on cascaded counters */
884 } else { /* TRIG_EXT */
885 /* trig on falling edge of external trigger */
888 } else if (cmd->scan_begin_src == TRIG_TIMER) {
889 /* burst mode with internal pacer clock */
890 control_c |= BMDE | IPCLK;
891 } else { /* TRIG_EXT */
892 /* burst mode with external trigger */
893 control_c |= BMDE | XPCLK;
896 das1800_ai_set_chanlist(dev, cmd->chanlist, cmd->chanlist_len);
898 /* setup cascaded counters for conversion/scan frequency */
899 if ((cmd->scan_begin_src == TRIG_FOLLOW ||
900 cmd->scan_begin_src == TRIG_TIMER) &&
901 cmd->convert_src == TRIG_TIMER) {
902 comedi_8254_update_divisors(dev->pacer);
903 comedi_8254_pacer_enable(dev->pacer, 1, 2, true);
906 /* setup counter 0 for 'about triggering' */
907 if (cmd->stop_src == TRIG_EXT)
908 comedi_8254_load(dev->pacer, 0, 1, I8254_MODE0 | I8254_BINARY);
910 das1800_ai_setup_dma(dev, s);
911 outb(control_c, dev->iobase + DAS1800_CONTROL_C);
912 /* set conversion rate and length for burst mode */
913 if (control_c & BMDE) {
914 outb(cmd->convert_arg / 1000 - 1, /* microseconds - 1 */
915 dev->iobase + DAS1800_BURST_RATE);
916 outb(cmd->chanlist_len - 1, dev->iobase + DAS1800_BURST_LENGTH);
919 /* enable and start conversions */
920 outb(devpriv->irq_dma_bits, dev->iobase + DAS1800_CONTROL_B);
921 outb(control_a, dev->iobase + DAS1800_CONTROL_A);
922 outb(CVEN, dev->iobase + DAS1800_STATUS);
927 static int das1800_ai_eoc(struct comedi_device *dev,
928 struct comedi_subdevice *s,
929 struct comedi_insn *insn,
930 unsigned long context)
932 unsigned char status;
934 status = inb(dev->iobase + DAS1800_STATUS);
940 static int das1800_ai_insn_read(struct comedi_device *dev,
941 struct comedi_subdevice *s,
942 struct comedi_insn *insn,
945 unsigned int range = CR_RANGE(insn->chanspec);
946 bool is_unipolar = comedi_range_is_unipolar(s, range);
952 outb(das1800_ai_chanspec_bits(s, insn->chanspec),
953 dev->iobase + DAS1800_CONTROL_C); /* software pacer */
954 outb(CVEN, dev->iobase + DAS1800_STATUS); /* enable conversions */
955 outb(0x0, dev->iobase + DAS1800_CONTROL_A); /* reset fifo */
956 outb(FFEN, dev->iobase + DAS1800_CONTROL_A);
958 das1800_ai_set_chanlist(dev, &insn->chanspec, 1);
960 /* protects the indirect addressing selected by DAS1800_SELECT */
961 spin_lock_irqsave(&dev->spinlock, flags);
963 /* select ai fifo register */
964 outb(ADC, dev->iobase + DAS1800_SELECT);
966 for (n = 0; n < insn->n; n++) {
967 /* trigger conversion */
968 outb(0, dev->iobase + DAS1800_FIFO);
970 ret = comedi_timeout(dev, s, insn, das1800_ai_eoc, 0);
974 dpnt = inw(dev->iobase + DAS1800_FIFO);
976 dpnt = comedi_offset_munge(s, dpnt);
979 spin_unlock_irqrestore(&dev->spinlock, flags);
981 return ret ? ret : insn->n;
984 static int das1800_ao_insn_write(struct comedi_device *dev,
985 struct comedi_subdevice *s,
986 struct comedi_insn *insn,
989 unsigned int chan = CR_CHAN(insn->chanspec);
990 unsigned int update_chan = s->n_chan - 1;
994 /* protects the indirect addressing selected by DAS1800_SELECT */
995 spin_lock_irqsave(&dev->spinlock, flags);
997 for (i = 0; i < insn->n; i++) {
998 unsigned int val = data[i];
1000 s->readback[chan] = val;
1002 val = comedi_offset_munge(s, val);
1004 /* load this channel (and update if it's the last channel) */
1005 outb(DAC(chan), dev->iobase + DAS1800_SELECT);
1006 outw(val, dev->iobase + DAS1800_DAC);
1008 /* update all channels */
1009 if (chan != update_chan) {
1010 val = comedi_offset_munge(s, s->readback[update_chan]);
1012 outb(DAC(update_chan), dev->iobase + DAS1800_SELECT);
1013 outw(val, dev->iobase + DAS1800_DAC);
1016 spin_unlock_irqrestore(&dev->spinlock, flags);
1021 static int das1800_di_insn_bits(struct comedi_device *dev,
1022 struct comedi_subdevice *s,
1023 struct comedi_insn *insn,
1026 data[1] = inb(dev->iobase + DAS1800_DIGITAL) & 0xf;
1032 static int das1800_do_insn_bits(struct comedi_device *dev,
1033 struct comedi_subdevice *s,
1034 struct comedi_insn *insn,
1037 if (comedi_dio_update_state(s, data))
1038 outb(s->state, dev->iobase + DAS1800_DIGITAL);
1045 static void das1800_init_dma(struct comedi_device *dev,
1046 struct comedi_devconfig *it)
1048 struct das1800_private *devpriv = dev->private;
1049 unsigned int *dma_chan;
1052 * it->options[2] is DMA channel 0
1053 * it->options[3] is DMA channel 1
1055 * Encode the DMA channels into 2 digit hexadecimal for switch.
1057 dma_chan = &it->options[2];
1059 switch ((dma_chan[0] & 0x7) | (dma_chan[1] << 4)) {
1060 case 0x5: /* dma0 == 5 */
1061 devpriv->dma_bits = DMA_CH5;
1063 case 0x6: /* dma0 == 6 */
1064 devpriv->dma_bits = DMA_CH6;
1066 case 0x7: /* dma0 == 7 */
1067 devpriv->dma_bits = DMA_CH7;
1069 case 0x65: /* dma0 == 5, dma1 == 6 */
1070 devpriv->dma_bits = DMA_CH5_CH6;
1072 case 0x76: /* dma0 == 6, dma1 == 7 */
1073 devpriv->dma_bits = DMA_CH6_CH7;
1075 case 0x57: /* dma0 == 7, dma1 == 5 */
1076 devpriv->dma_bits = DMA_CH7_CH5;
1082 /* DMA can use 1 or 2 buffers, each with a separate channel */
1083 devpriv->dma = comedi_isadma_alloc(dev, dma_chan[1] ? 2 : 1,
1084 dma_chan[0], dma_chan[1],
1085 DMA_BUF_SIZE, COMEDI_ISADMA_READ);
1087 devpriv->dma_bits = 0;
1090 static void das1800_free_dma(struct comedi_device *dev)
1092 struct das1800_private *devpriv = dev->private;
1095 comedi_isadma_free(devpriv->dma);
1098 static int das1800_probe(struct comedi_device *dev)
1100 const struct das1800_board *board = dev->board_ptr;
1103 id = (inb(dev->iobase + DAS1800_DIGITAL) >> 4) & 0xf;
1106 * The dev->board_ptr will be set by comedi_device_attach() if the
1107 * board name provided by the user matches a board->name in this
1108 * driver. If so, this function sanity checks the id to verify that
1109 * the board is correct.
1112 if (board->id == id)
1114 dev_err(dev->class_dev,
1115 "probed id does not match board id (0x%x != 0x%x)\n",
1121 * If the dev->board_ptr is not set, the user is trying to attach
1122 * an unspecified board to this driver. In this case the id is used
1123 * to 'probe' for the dev->board_ptr.
1126 case DAS1800_ID_ST_DA:
1127 /* das-1701st-da, das-1702st-da, das-1801st-da, das-1802st-da */
1128 board = &das1800_boards[BOARD_DAS1801ST_DA];
1130 case DAS1800_ID_HR_DA:
1131 /* das-1702hr-da, das-1802hr-da */
1132 board = &das1800_boards[BOARD_DAS1802HR_DA];
1135 /* das-1701ao, das-1702ao, das-1801ao, das-1802ao */
1136 board = &das1800_boards[BOARD_DAS1801AO];
1139 /* das-1702hr, das-1802hr */
1140 board = &das1800_boards[BOARD_DAS1802HR];
1143 /* das-1701st, das-1702st, das-1801st, das-1802st */
1144 board = &das1800_boards[BOARD_DAS1801ST];
1147 /* das-1801hc, das-1802hc */
1148 board = &das1800_boards[BOARD_DAS1801HC];
1151 dev_err(dev->class_dev, "invalid probe id 0x%x\n", id);
1154 dev->board_ptr = board;
1155 dev->board_name = board->name;
1156 dev_warn(dev->class_dev,
1157 "probed id 0x%0x: %s series (not recommended)\n",
1162 static int das1800_attach(struct comedi_device *dev,
1163 struct comedi_devconfig *it)
1165 const struct das1800_board *board;
1166 struct das1800_private *devpriv;
1167 struct comedi_subdevice *s;
1168 unsigned int irq = it->options[1];
1173 devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
1177 ret = comedi_request_region(dev, it->options[0], DAS1800_SIZE);
1181 ret = das1800_probe(dev);
1184 board = dev->board_ptr;
1186 is_16bit = board->id == DAS1800_ID_HR || board->id == DAS1800_ID_HR_DA;
1188 /* waveform 'ao' boards have additional io ports */
1189 if (board->id == DAS1800_ID_AO) {
1190 unsigned long iobase2 = dev->iobase + IOBASE2;
1192 ret = __comedi_request_region(dev, iobase2, DAS1800_SIZE);
1195 devpriv->iobase2 = iobase2;
1198 if (irq == 3 || irq == 5 || irq == 7 || irq == 10 || irq == 11 ||
1200 ret = request_irq(irq, das1800_interrupt, 0,
1201 dev->board_name, dev);
1207 devpriv->irq_dma_bits |= 0x8;
1210 devpriv->irq_dma_bits |= 0x10;
1213 devpriv->irq_dma_bits |= 0x18;
1216 devpriv->irq_dma_bits |= 0x28;
1219 devpriv->irq_dma_bits |= 0x30;
1222 devpriv->irq_dma_bits |= 0x38;
1228 /* an irq and one dma channel is required to use dma */
1229 if (dev->irq & it->options[2])
1230 das1800_init_dma(dev, it);
1232 devpriv->fifo_buf = kmalloc_array(FIFO_SIZE,
1233 sizeof(*devpriv->fifo_buf),
1235 if (!devpriv->fifo_buf)
1238 dev->pacer = comedi_8254_init(dev->iobase + DAS1800_COUNTER,
1239 I8254_OSC_BASE_5MHZ, I8254_IO8, 0);
1243 ret = comedi_alloc_subdevices(dev, 4);
1248 * Analog Input subdevice
1250 * The "hc" type boards have 64 analog input channels and a 64
1253 * All the other board types have 16 on-board channels. Each channel
1254 * can be expanded to 16 channels with the addition of an EXP-1800
1255 * expansion board for a total of 256 channels. The QRAM fifo on
1256 * these boards has 256 entries.
1258 * From the datasheets it's not clear what the comedi channel to
1259 * actual physical channel mapping is when EXP-1800 boards are used.
1261 s = &dev->subdevices[0];
1262 s->type = COMEDI_SUBD_AI;
1263 s->subdev_flags = SDF_READABLE | SDF_DIFF | SDF_GROUND;
1264 if (board->id != DAS1800_ID_HC)
1265 s->subdev_flags |= SDF_COMMON;
1266 s->n_chan = (board->id == DAS1800_ID_HC) ? 64 : 256;
1267 s->maxdata = is_16bit ? 0xffff : 0x0fff;
1268 s->range_table = board->is_01_series ? &das1801_ai_range
1269 : &das1802_ai_range;
1270 s->insn_read = das1800_ai_insn_read;
1272 dev->read_subdev = s;
1273 s->subdev_flags |= SDF_CMD_READ;
1274 s->len_chanlist = s->n_chan;
1275 s->do_cmd = das1800_ai_cmd;
1276 s->do_cmdtest = das1800_ai_cmdtest;
1277 s->poll = das1800_ai_poll;
1278 s->cancel = das1800_ai_cancel;
1279 s->munge = das1800_ai_munge;
1282 /* Analog Output subdevice */
1283 s = &dev->subdevices[1];
1284 if (board->id == DAS1800_ID_ST_DA || board->id == DAS1800_ID_HR_DA) {
1285 s->type = COMEDI_SUBD_AO;
1286 s->subdev_flags = SDF_WRITABLE;
1287 s->n_chan = (board->id == DAS1800_ID_ST_DA) ? 4 : 2;
1288 s->maxdata = is_16bit ? 0xffff : 0x0fff;
1289 s->range_table = &range_bipolar10;
1290 s->insn_write = das1800_ao_insn_write;
1292 ret = comedi_alloc_subdev_readback(s);
1296 /* initialize all channels to 0V */
1297 for (i = 0; i < s->n_chan; i++) {
1298 /* spinlock is not necessary during the attach */
1299 outb(DAC(i), dev->iobase + DAS1800_SELECT);
1300 outw(0, dev->iobase + DAS1800_DAC);
1302 } else if (board->id == DAS1800_ID_AO) {
1304 * 'ao' boards have waveform analog outputs that are not
1305 * currently supported.
1307 s->type = COMEDI_SUBD_UNUSED;
1309 s->type = COMEDI_SUBD_UNUSED;
1312 /* Digital Input subdevice */
1313 s = &dev->subdevices[2];
1314 s->type = COMEDI_SUBD_DI;
1315 s->subdev_flags = SDF_READABLE;
1318 s->range_table = &range_digital;
1319 s->insn_bits = das1800_di_insn_bits;
1321 /* Digital Output subdevice */
1322 s = &dev->subdevices[3];
1323 s->type = COMEDI_SUBD_DO;
1324 s->subdev_flags = SDF_WRITABLE;
1325 s->n_chan = (board->id == DAS1800_ID_HC) ? 8 : 4;
1327 s->range_table = &range_digital;
1328 s->insn_bits = das1800_do_insn_bits;
1330 das1800_ai_cancel(dev, dev->read_subdev);
1332 /* initialize digital out channels */
1333 outb(0, dev->iobase + DAS1800_DIGITAL);
1338 static void das1800_detach(struct comedi_device *dev)
1340 struct das1800_private *devpriv = dev->private;
1342 das1800_free_dma(dev);
1344 kfree(devpriv->fifo_buf);
1345 if (devpriv->iobase2)
1346 release_region(devpriv->iobase2, DAS1800_SIZE);
1348 comedi_legacy_detach(dev);
1351 static struct comedi_driver das1800_driver = {
1352 .driver_name = "das1800",
1353 .module = THIS_MODULE,
1354 .attach = das1800_attach,
1355 .detach = das1800_detach,
1356 .num_names = ARRAY_SIZE(das1800_boards),
1357 .board_name = &das1800_boards[0].name,
1358 .offset = sizeof(struct das1800_board),
1360 module_comedi_driver(das1800_driver);
1362 MODULE_AUTHOR("Comedi https://www.comedi.org");
1363 MODULE_DESCRIPTION("Comedi driver for DAS1800 compatible ISA boards");
1364 MODULE_LICENSE("GPL");