2 * comedi/drivers/dt2801.c
3 * Device Driver for DataTranslation DT2801
8 Description: Data Translation DT2801 series and DT01-EZ
11 Devices: [Data Translation] DT2801 (dt2801), DT2801-A, DT2801/5716A,
12 DT2805, DT2805/5716A, DT2808, DT2818, DT2809, DT01-EZ
14 This driver can autoprobe the type of board.
16 Configuration options:
17 [0] - I/O port base address
19 [2] - A/D reference 0=differential, 1=single-ended
29 [5] - D/A 1 range (same choices)
32 #include "../comedidev.h"
33 #include <linux/delay.h>
34 #include <linux/ioport.h>
36 #define DT2801_TIMEOUT 1000
38 /* Hardware Configuration */
39 /* ====================== */
41 #define DT2801_MAX_DMA_SIZE (64 * 1024)
44 #define DT2801_IOSIZE 2
47 /* ====================== */
50 #define DT_C_RESET 0x0
51 #define DT_C_CLEAR_ERR 0x1
52 #define DT_C_READ_ERRREG 0x2
53 #define DT_C_SET_CLOCK 0x3
58 #define DT_C_SET_DIGIN 0x4
59 #define DT_C_SET_DIGOUT 0x5
60 #define DT_C_READ_DIG 0x6
61 #define DT_C_WRITE_DIG 0x7
63 #define DT_C_WRITE_DAIM 0x8
64 #define DT_C_SET_DA 0x9
65 #define DT_C_WRITE_DA 0xa
67 #define DT_C_READ_ADIM 0xc
68 #define DT_C_SET_AD 0xd
69 #define DT_C_READ_AD 0xe
71 /* Command modifiers (only used with read/write), EXTTRIG can be
72 used with some other commands.
74 #define DT_MOD_DMA (1<<4)
75 #define DT_MOD_CONT (1<<5)
76 #define DT_MOD_EXTCLK (1<<6)
77 #define DT_MOD_EXTTRIG (1<<7)
79 /* Bits in status register */
80 #define DT_S_DATA_OUT_READY (1<<0)
81 #define DT_S_DATA_IN_FULL (1<<1)
82 #define DT_S_READY (1<<2)
83 #define DT_S_COMMAND (1<<3)
84 #define DT_S_COMPOSITE_ERROR (1<<7)
88 #define DT2801_STATUS 1
91 static int dt2801_attach(struct comedi_device *dev,
92 struct comedi_devconfig *it);
93 static int dt2801_detach(struct comedi_device *dev);
94 static struct comedi_driver driver_dt2801 = {
95 .driver_name = "dt2801",
96 .module = THIS_MODULE,
97 .attach = dt2801_attach,
98 .detach = dt2801_detach,
101 COMEDI_INITCLEANUP(driver_dt2801);
104 /* ignore 'defined but not used' warning */
105 static const struct comedi_lrange range_dt2801_ai_pgh_bipolar = { 4, {
119 static const struct comedi_lrange range_dt2801_ai_pgl_bipolar = { 4, {
134 /* ignore 'defined but not used' warning */
135 static const struct comedi_lrange range_dt2801_ai_pgh_unipolar = { 4, {
147 static const struct comedi_lrange range_dt2801_ai_pgl_unipolar = { 4, {
159 struct dt2801_board {
170 /* Typeid's for the different boards of the DT2801-series
171 (taken from the test-software, that comes with the board)
173 static const struct dt2801_board boardtypes[] = {
191 .name = "dt2801/5716a",
207 .name = "dt2805/5716a",
240 #define boardtype (*(const struct dt2801_board *)dev->board_ptr)
242 struct dt2801_private {
244 const struct comedi_lrange *dac_range_types[2];
245 unsigned int ao_readback[2];
248 #define devpriv ((struct dt2801_private *)dev->private)
250 static int dt2801_ai_insn_read(struct comedi_device *dev,
251 struct comedi_subdevice *s,
252 struct comedi_insn *insn, unsigned int *data);
253 static int dt2801_ao_insn_read(struct comedi_device *dev,
254 struct comedi_subdevice *s,
255 struct comedi_insn *insn, unsigned int *data);
256 static int dt2801_ao_insn_write(struct comedi_device *dev,
257 struct comedi_subdevice *s,
258 struct comedi_insn *insn, unsigned int *data);
259 static int dt2801_dio_insn_bits(struct comedi_device *dev,
260 struct comedi_subdevice *s,
261 struct comedi_insn *insn, unsigned int *data);
262 static int dt2801_dio_insn_config(struct comedi_device *dev,
263 struct comedi_subdevice *s,
264 struct comedi_insn *insn, unsigned int *data);
266 /* These are the low-level routines:
267 writecommand: write a command to the board
268 writedata: write data byte
269 readdata: read data byte
272 /* Only checks DataOutReady-flag, not the Ready-flag as it is done
273 in the examples of the manual. I don't see why this should be
275 static int dt2801_readdata(struct comedi_device *dev, int *data)
278 int timeout = DT2801_TIMEOUT;
281 stat = inb_p(dev->iobase + DT2801_STATUS);
282 if (stat & (DT_S_COMPOSITE_ERROR | DT_S_READY)) {
285 if (stat & DT_S_DATA_OUT_READY) {
286 *data = inb_p(dev->iobase + DT2801_DATA);
289 } while (--timeout > 0);
294 static int dt2801_readdata2(struct comedi_device *dev, int *data)
299 ret = dt2801_readdata(dev, &lb);
302 ret = dt2801_readdata(dev, &hb);
306 *data = (hb << 8) + lb;
310 static int dt2801_writedata(struct comedi_device *dev, unsigned int data)
313 int timeout = DT2801_TIMEOUT;
316 stat = inb_p(dev->iobase + DT2801_STATUS);
318 if (stat & DT_S_COMPOSITE_ERROR) {
321 if (!(stat & DT_S_DATA_IN_FULL)) {
322 outb_p(data & 0xff, dev->iobase + DT2801_DATA);
326 if (stat & DT_S_READY) {
328 ("dt2801: ready flag set (bad!) in dt2801_writedata()\n");
332 } while (--timeout > 0);
337 static int dt2801_writedata2(struct comedi_device *dev, unsigned int data)
341 ret = dt2801_writedata(dev, data & 0xff);
344 ret = dt2801_writedata(dev, (data >> 8));
351 static int dt2801_wait_for_ready(struct comedi_device *dev)
353 int timeout = DT2801_TIMEOUT;
356 stat = inb_p(dev->iobase + DT2801_STATUS);
357 if (stat & DT_S_READY) {
361 stat = inb_p(dev->iobase + DT2801_STATUS);
363 if (stat & DT_S_COMPOSITE_ERROR) {
366 if (stat & DT_S_READY) {
369 } while (--timeout > 0);
374 static int dt2801_writecmd(struct comedi_device *dev, int command)
378 dt2801_wait_for_ready(dev);
380 stat = inb_p(dev->iobase + DT2801_STATUS);
381 if (stat & DT_S_COMPOSITE_ERROR) {
383 ("dt2801: composite-error in dt2801_writecmd(), ignoring\n");
385 if (!(stat & DT_S_READY)) {
386 printk("dt2801: !ready in dt2801_writecmd(), ignoring\n");
388 outb_p(command, dev->iobase + DT2801_CMD);
393 static int dt2801_reset(struct comedi_device *dev)
399 DPRINTK("dt2801: resetting board...\n");
400 DPRINTK("fingerprint: 0x%02x 0x%02x\n", inb_p(dev->iobase),
401 inb_p(dev->iobase + 1));
403 /* pull random data from data port */
404 inb_p(dev->iobase + DT2801_DATA);
405 inb_p(dev->iobase + DT2801_DATA);
406 inb_p(dev->iobase + DT2801_DATA);
407 inb_p(dev->iobase + DT2801_DATA);
409 DPRINTK("dt2801: stop\n");
410 /* dt2801_writecmd(dev,DT_C_STOP); */
411 outb_p(DT_C_STOP, dev->iobase + DT2801_CMD);
413 /* dt2801_wait_for_ready(dev); */
417 stat = inb_p(dev->iobase + DT2801_STATUS);
418 if (stat & DT_S_READY)
422 printk("dt2801: timeout 1 status=0x%02x\n", stat);
425 /* printk("dt2801: reading dummy\n"); */
426 /* dt2801_readdata(dev,&board_code); */
428 DPRINTK("dt2801: reset\n");
429 outb_p(DT_C_RESET, dev->iobase + DT2801_CMD);
430 /* dt2801_writecmd(dev,DT_C_RESET); */
435 stat = inb_p(dev->iobase + DT2801_STATUS);
436 if (stat & DT_S_READY)
440 printk("dt2801: timeout 2 status=0x%02x\n", stat);
443 DPRINTK("dt2801: reading code\n");
444 dt2801_readdata(dev, &board_code);
446 DPRINTK("dt2801: ok. code=0x%02x\n", board_code);
451 static int probe_number_of_ai_chans(struct comedi_device *dev)
457 for (n_chans = 0; n_chans < 16; n_chans++) {
458 stat = dt2801_writecmd(dev, DT_C_READ_ADIM);
459 dt2801_writedata(dev, 0);
460 dt2801_writedata(dev, n_chans);
461 stat = dt2801_readdata2(dev, &data);
473 static const struct comedi_lrange *dac_range_table[] = {
481 static const struct comedi_lrange *dac_range_lkup(int opt)
483 if (opt < 0 || opt > 5)
484 return &range_unknown;
485 return dac_range_table[opt];
488 static const struct comedi_lrange *ai_range_lkup(int type, int opt)
493 &range_dt2801_ai_pgl_unipolar :
494 &range_dt2801_ai_pgl_bipolar;
496 return (opt) ? &range_unipolar10 : &range_bipolar10;
498 return &range_unipolar5;
500 return &range_unknown;
507 [2] - a/d 0=differential, 1=single-ended
508 [3] - a/d range 0=[-10,10], 1=[0,10]
509 [4] - dac0 range 0=[-10,10], 1=[-5,5], 2=[-2.5,2.5] 3=[0,10], 4=[0,5]
510 [5] - dac1 range 0=[-10,10], 1=[-5,5], 2=[-2.5,2.5] 3=[0,10], 4=[0,5]
512 static int dt2801_attach(struct comedi_device *dev, struct comedi_devconfig *it)
514 struct comedi_subdevice *s;
515 unsigned long iobase;
516 int board_code, type;
520 iobase = it->options[0];
521 if (!request_region(iobase, DT2801_IOSIZE, "dt2801")) {
522 comedi_error(dev, "I/O port conflict");
525 dev->iobase = iobase;
527 /* do some checking */
529 board_code = dt2801_reset(dev);
531 /* heh. if it didn't work, try it again. */
533 board_code = dt2801_reset(dev);
535 for (type = 0; type < ARRAY_SIZE(boardtypes); type++) {
536 if (boardtypes[type].boardcode == board_code)
539 printk("dt2801: unrecognized board code=0x%02x, contact author\n",
544 dev->board_ptr = boardtypes + type;
545 printk("dt2801: %s at port 0x%lx", boardtype.name, iobase);
547 n_ai_chans = probe_number_of_ai_chans(dev);
548 printk(" (ai channels = %d)", n_ai_chans);
550 ret = alloc_subdevices(dev, 4);
554 ret = alloc_private(dev, sizeof(struct dt2801_private));
558 dev->board_name = boardtype.name;
560 s = dev->subdevices + 0;
562 s->type = COMEDI_SUBD_AI;
563 s->subdev_flags = SDF_READABLE | SDF_GROUND;
565 s->n_chan = n_ai_chans;
568 s->n_chan = boardtype.ad_chan;
570 s->n_chan = boardtype.ad_chan / 2;
572 s->maxdata = (1 << boardtype.adbits) - 1;
573 s->range_table = ai_range_lkup(boardtype.adrangetype, it->options[3]);
574 s->insn_read = dt2801_ai_insn_read;
578 s->type = COMEDI_SUBD_AO;
579 s->subdev_flags = SDF_WRITABLE;
581 s->maxdata = (1 << boardtype.dabits) - 1;
582 s->range_table_list = devpriv->dac_range_types;
583 devpriv->dac_range_types[0] = dac_range_lkup(it->options[4]);
584 devpriv->dac_range_types[1] = dac_range_lkup(it->options[5]);
585 s->insn_read = dt2801_ao_insn_read;
586 s->insn_write = dt2801_ao_insn_write;
589 /* 1st digital subdevice */
590 s->type = COMEDI_SUBD_DIO;
591 s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
594 s->range_table = &range_digital;
595 s->insn_bits = dt2801_dio_insn_bits;
596 s->insn_config = dt2801_dio_insn_config;
599 /* 2nd digital subdevice */
600 s->type = COMEDI_SUBD_DIO;
601 s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
604 s->range_table = &range_digital;
605 s->insn_bits = dt2801_dio_insn_bits;
606 s->insn_config = dt2801_dio_insn_config;
615 static int dt2801_detach(struct comedi_device *dev)
618 release_region(dev->iobase, DT2801_IOSIZE);
623 static int dt2801_error(struct comedi_device *dev, int stat)
626 if (stat == -ETIME) {
627 printk("dt2801: timeout\n");
629 printk("dt2801: error %d\n", stat);
633 printk("dt2801: error status 0x%02x, resetting...\n", stat);
641 static int dt2801_ai_insn_read(struct comedi_device *dev,
642 struct comedi_subdevice *s,
643 struct comedi_insn *insn, unsigned int *data)
649 for (i = 0; i < insn->n; i++) {
650 stat = dt2801_writecmd(dev, DT_C_READ_ADIM);
651 dt2801_writedata(dev, CR_RANGE(insn->chanspec));
652 dt2801_writedata(dev, CR_CHAN(insn->chanspec));
653 stat = dt2801_readdata2(dev, &d);
656 return dt2801_error(dev, stat);
664 static int dt2801_ao_insn_read(struct comedi_device *dev,
665 struct comedi_subdevice *s,
666 struct comedi_insn *insn, unsigned int *data)
668 data[0] = devpriv->ao_readback[CR_CHAN(insn->chanspec)];
673 static int dt2801_ao_insn_write(struct comedi_device *dev,
674 struct comedi_subdevice *s,
675 struct comedi_insn *insn, unsigned int *data)
677 dt2801_writecmd(dev, DT_C_WRITE_DAIM);
678 dt2801_writedata(dev, CR_CHAN(insn->chanspec));
679 dt2801_writedata2(dev, data[0]);
681 devpriv->ao_readback[CR_CHAN(insn->chanspec)] = data[0];
686 static int dt2801_dio_insn_bits(struct comedi_device *dev,
687 struct comedi_subdevice *s,
688 struct comedi_insn *insn, unsigned int *data)
692 if (s == dev->subdevices + 4)
698 s->state &= ~data[0];
699 s->state |= (data[0] & data[1]);
700 dt2801_writecmd(dev, DT_C_WRITE_DIG);
701 dt2801_writedata(dev, which);
702 dt2801_writedata(dev, s->state);
704 dt2801_writecmd(dev, DT_C_READ_DIG);
705 dt2801_writedata(dev, which);
706 dt2801_readdata(dev, data + 1);
711 static int dt2801_dio_insn_config(struct comedi_device *dev,
712 struct comedi_subdevice *s,
713 struct comedi_insn *insn, unsigned int *data)
717 if (s == dev->subdevices + 4)
723 dt2801_writecmd(dev, DT_C_SET_DIGOUT);
726 dt2801_writecmd(dev, DT_C_SET_DIGIN);
728 dt2801_writedata(dev, which);