drivers/staging/comedi/drivers/ni_atmio16d.c

   1 /*
   2    comedi/drivers/ni_atmio16d.c
   3    Hardware driver for National Instruments AT-MIO16D board
   4    Copyright (C) 2000 Chris R. Baugher <baugher@enteract.com>
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15  */
  16 /*
  17 Driver: ni_atmio16d
  18 Description: National Instruments AT-MIO-16D
  19 Author: Chris R. Baugher <baugher@enteract.com>
  20 Status: unknown
  21 Devices: [National Instruments] AT-MIO-16 (atmio16), AT-MIO-16D (atmio16d)
  22 */
  23 /*
  24  * I must give credit here to Michal Dobes <dobes@tesnet.cz> who
  25  * wrote the driver for Advantec's pcl812 boards. I used the interrupt
  26  * handling code from his driver as an example for this one.
  27  *
  28  * Chris Baugher
  29  * 5/1/2000
  30  *
  31  */
  32
  33 #include <linux/module.h>
  34 #include <linux/interrupt.h>
  35 #include "../comedidev.h"
  36
  37 #include "comedi_fc.h"
  38 #include "8255.h"
  39
  40 /* Configuration and Status Registers */
  41 #define COM_REG_1       0x00    /* wo 16 */
  42 #define STAT_REG        0x00    /* ro 16 */
  43 #define COM_REG_2       0x02    /* wo 16 */
  44 /* Event Strobe Registers */
  45 #define START_CONVERT_REG       0x08    /* wo 16 */
  46 #define START_DAQ_REG           0x0A    /* wo 16 */
  47 #define AD_CLEAR_REG            0x0C    /* wo 16 */
  48 #define EXT_STROBE_REG          0x0E    /* wo 16 */
  49 /* Analog Output Registers */
  50 #define DAC0_REG                0x10    /* wo 16 */
  51 #define DAC1_REG                0x12    /* wo 16 */
  52 #define INT2CLR_REG             0x14    /* wo 16 */
  53 /* Analog Input Registers */
  54 #define MUX_CNTR_REG            0x04    /* wo 16 */
  55 #define MUX_GAIN_REG            0x06    /* wo 16 */
  56 #define AD_FIFO_REG             0x16    /* ro 16 */
  57 #define DMA_TC_INT_CLR_REG      0x16    /* wo 16 */
  58 /* AM9513A Counter/Timer Registers */
  59 #define AM9513A_DATA_REG        0x18    /* rw 16 */
  60 #define AM9513A_COM_REG         0x1A    /* wo 16 */
  61 #define AM9513A_STAT_REG        0x1A    /* ro 16 */
  62 /* MIO-16 Digital I/O Registers */
  63 #define MIO_16_DIG_IN_REG       0x1C    /* ro 16 */
  64 #define MIO_16_DIG_OUT_REG      0x1C    /* wo 16 */
  65 /* RTSI Switch Registers */
  66 #define RTSI_SW_SHIFT_REG       0x1E    /* wo 8 */
  67 #define RTSI_SW_STROBE_REG      0x1F    /* wo 8 */
  68 /* DIO-24 Registers */
  69 #define DIO_24_PORTA_REG        0x00    /* rw 8 */
  70 #define DIO_24_PORTB_REG        0x01    /* rw 8 */
  71 #define DIO_24_PORTC_REG        0x02    /* rw 8 */
  72 #define DIO_24_CNFG_REG         0x03    /* wo 8 */
  73
  74 /* Command Register bits */
  75 #define COMREG1_2SCADC          0x0001
  76 #define COMREG1_1632CNT         0x0002
  77 #define COMREG1_SCANEN          0x0008
  78 #define COMREG1_DAQEN           0x0010
  79 #define COMREG1_DMAEN           0x0020
  80 #define COMREG1_CONVINTEN       0x0080
  81 #define COMREG2_SCN2            0x0010
  82 #define COMREG2_INTEN           0x0080
  83 #define COMREG2_DOUTEN0         0x0100
  84 #define COMREG2_DOUTEN1         0x0200
  85 /* Status Register bits */
  86 #define STAT_AD_OVERRUN         0x0100
  87 #define STAT_AD_OVERFLOW        0x0200
  88 #define STAT_AD_DAQPROG         0x0800
  89 #define STAT_AD_CONVAVAIL       0x2000
  90 #define STAT_AD_DAQSTOPINT      0x4000
  91 /* AM9513A Counter/Timer defines */
  92 #define CLOCK_1_MHZ             0x8B25
  93 #define CLOCK_100_KHZ   0x8C25
  94 #define CLOCK_10_KHZ    0x8D25
  95 #define CLOCK_1_KHZ             0x8E25
  96 #define CLOCK_100_HZ    0x8F25
  97 /* Other miscellaneous defines */
  98 #define ATMIO16D_SIZE   32      /* bus address range */
  99 #define ATMIO16D_TIMEOUT 10
 100
 101 struct atmio16_board_t {
 102
 103         const char *name;
 104         int has_8255;
 105 };
 106
 107 /* range structs */
 108 static const struct comedi_lrange range_atmio16d_ai_10_bipolar = { 4, {
 109                                                                        BIP_RANGE
 110                                                                        (10),
 111                                                                        BIP_RANGE
 112                                                                        (1),
 113                                                                        BIP_RANGE
 114                                                                        (0.1),
 115                                                                        BIP_RANGE
 116                                                                        (0.02)
 117                                                                        }
 118 };
 119
 120 static const struct comedi_lrange range_atmio16d_ai_5_bipolar = { 4, {
 121                                                                       BIP_RANGE
 122                                                                       (5),
 123                                                                       BIP_RANGE
 124                                                                       (0.5),
 125                                                                       BIP_RANGE
 126                                                                       (0.05),
 127                                                                       BIP_RANGE
 128                                                                       (0.01)
 129                                                                       }
 130 };
 131
 132 static const struct comedi_lrange range_atmio16d_ai_unipolar = { 4, {
 133                                                                      UNI_RANGE
 134                                                                      (10),
 135                                                                      UNI_RANGE
 136                                                                      (1),
 137                                                                      UNI_RANGE
 138                                                                      (0.1),
 139                                                                      UNI_RANGE
 140                                                                      (0.02)
 141                                                                      }
 142 };
 143
 144 /* private data struct */
 145 struct atmio16d_private {
 146         enum { adc_diff, adc_singleended } adc_mux;
 147         enum { adc_bipolar10, adc_bipolar5, adc_unipolar10 } adc_range;
 148         enum { adc_2comp, adc_straight } adc_coding;
 149         enum { dac_bipolar, dac_unipolar } dac0_range, dac1_range;
 150         enum { dac_internal, dac_external } dac0_reference, dac1_reference;
 151         enum { dac_2comp, dac_straight } dac0_coding, dac1_coding;
 152         const struct comedi_lrange *ao_range_type_list[2];
 153         unsigned int ao_readback[2];
 154         unsigned int com_reg_1_state; /* current state of command register 1 */
 155         unsigned int com_reg_2_state; /* current state of command register 2 */
 156 };
 157
 158 static void reset_counters(struct comedi_device *dev)
 159 {
 160         /* Counter 2 */
 161         outw(0xFFC2, dev->iobase + AM9513A_COM_REG);
 162         outw(0xFF02, dev->iobase + AM9513A_COM_REG);
 163         outw(0x4, dev->iobase + AM9513A_DATA_REG);
 164         outw(0xFF0A, dev->iobase + AM9513A_COM_REG);
 165         outw(0x3, dev->iobase + AM9513A_DATA_REG);
 166         outw(0xFF42, dev->iobase + AM9513A_COM_REG);
 167         outw(0xFF42, dev->iobase + AM9513A_COM_REG);
 168         /* Counter 3 */
 169         outw(0xFFC4, dev->iobase + AM9513A_COM_REG);
 170         outw(0xFF03, dev->iobase + AM9513A_COM_REG);
 171         outw(0x4, dev->iobase + AM9513A_DATA_REG);
 172         outw(0xFF0B, dev->iobase + AM9513A_COM_REG);
 173         outw(0x3, dev->iobase + AM9513A_DATA_REG);
 174         outw(0xFF44, dev->iobase + AM9513A_COM_REG);
 175         outw(0xFF44, dev->iobase + AM9513A_COM_REG);
 176         /* Counter 4 */
 177         outw(0xFFC8, dev->iobase + AM9513A_COM_REG);
 178         outw(0xFF04, dev->iobase + AM9513A_COM_REG);
 179         outw(0x4, dev->iobase + AM9513A_DATA_REG);
 180         outw(0xFF0C, dev->iobase + AM9513A_COM_REG);
 181         outw(0x3, dev->iobase + AM9513A_DATA_REG);
 182         outw(0xFF48, dev->iobase + AM9513A_COM_REG);
 183         outw(0xFF48, dev->iobase + AM9513A_COM_REG);
 184         /* Counter 5 */
 185         outw(0xFFD0, dev->iobase + AM9513A_COM_REG);
 186         outw(0xFF05, dev->iobase + AM9513A_COM_REG);
 187         outw(0x4, dev->iobase + AM9513A_DATA_REG);
 188         outw(0xFF0D, dev->iobase + AM9513A_COM_REG);
 189         outw(0x3, dev->iobase + AM9513A_DATA_REG);
 190         outw(0xFF50, dev->iobase + AM9513A_COM_REG);
 191         outw(0xFF50, dev->iobase + AM9513A_COM_REG);
 192
 193         outw(0, dev->iobase + AD_CLEAR_REG);
 194 }
 195
 196 static void reset_atmio16d(struct comedi_device *dev)
 197 {
 198         struct atmio16d_private *devpriv = dev->private;
 199         int i;
 200
 201         /* now we need to initialize the board */
 202         outw(0, dev->iobase + COM_REG_1);
 203         outw(0, dev->iobase + COM_REG_2);
 204         outw(0, dev->iobase + MUX_GAIN_REG);
 205         /* init AM9513A timer */
 206         outw(0xFFFF, dev->iobase + AM9513A_COM_REG);
 207         outw(0xFFEF, dev->iobase + AM9513A_COM_REG);
 208         outw(0xFF17, dev->iobase + AM9513A_COM_REG);
 209         outw(0xF000, dev->iobase + AM9513A_DATA_REG);
 210         for (i = 1; i <= 5; ++i) {
 211                 outw(0xFF00 + i, dev->iobase + AM9513A_COM_REG);
 212                 outw(0x0004, dev->iobase + AM9513A_DATA_REG);
 213                 outw(0xFF08 + i, dev->iobase + AM9513A_COM_REG);
 214                 outw(0x3, dev->iobase + AM9513A_DATA_REG);
 215         }
 216         outw(0xFF5F, dev->iobase + AM9513A_COM_REG);
 217         /* timer init done */
 218         outw(0, dev->iobase + AD_CLEAR_REG);
 219         outw(0, dev->iobase + INT2CLR_REG);
 220         /* select straight binary mode for Analog Input */
 221         devpriv->com_reg_1_state |= 1;
 222         outw(devpriv->com_reg_1_state, dev->iobase + COM_REG_1);
 223         devpriv->adc_coding = adc_straight;
 224         /* zero the analog outputs */
 225         outw(2048, dev->iobase + DAC0_REG);
 226         outw(2048, dev->iobase + DAC1_REG);
 227 }
 228
 229 static irqreturn_t atmio16d_interrupt(int irq, void *d)
 230 {
 231         struct comedi_device *dev = d;
 232         struct comedi_subdevice *s = &dev->subdevices[0];
 233
 234         comedi_buf_put(s->async, inw(dev->iobase + AD_FIFO_REG));
 235
 236         comedi_event(dev, s);
 237         return IRQ_HANDLED;
 238 }
 239
 240 static int atmio16d_ai_cmdtest(struct comedi_device *dev,
 241                                struct comedi_subdevice *s,
 242                                struct comedi_cmd *cmd)
 243 {
 244         int err = 0;
 245
 246         /* Step 1 : check if triggers are trivially valid */
 247
 248         err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
 249         err |= cfc_check_trigger_src(&cmd->scan_begin_src,
 250                                         TRIG_FOLLOW | TRIG_TIMER);
 251         err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_TIMER);
 252         err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
 253         err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
 254
 255         if (err)
 256                 return 1;
 257
 258         /* Step 2a : make sure trigger sources are unique */
 259
 260         err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
 261         err |= cfc_check_trigger_is_unique(cmd->stop_src);
 262
 263         /* Step 2b : and mutually compatible */
 264
 265         if (err)
 266                 return 2;
 267
 268         /* Step 3: check if arguments are trivially valid */
 269
 270         err |= cfc_check_trigger_arg_is(&cmd->start_arg, 0);
 271
 272         if (cmd->scan_begin_src == TRIG_FOLLOW) {
 273                 /* internal trigger */
 274                 err |= cfc_check_trigger_arg_is(&cmd->scan_begin_arg, 0);
 275         } else {
 276 #if 0
 277                 /* external trigger */
 278                 /* should be level/edge, hi/lo specification here */
 279                 err |= cfc_check_trigger_arg_is(&cmd->scan_begin_arg, 0);
 280 #endif
 281         }
 282
 283         err |= cfc_check_trigger_arg_min(&cmd->convert_arg, 10000);
 284 #if 0
 285         err |= cfc_check_trigger_arg_max(&cmd->convert_arg, SLOWEST_TIMER);
 286 #endif
 287
 288         err |= cfc_check_trigger_arg_is(&cmd->scan_end_arg, cmd->chanlist_len);
 289
 290         if (cmd->stop_src == TRIG_COUNT) {
 291                 /* any count is allowed */
 292         } else {        /* TRIG_NONE */
 293                 err |= cfc_check_trigger_arg_is(&cmd->stop_arg, 0);
 294         }
 295
 296         if (err)
 297                 return 3;
 298
 299         return 0;
 300 }
 301
 302 static int atmio16d_ai_cmd(struct comedi_device *dev,
 303                            struct comedi_subdevice *s)
 304 {
 305         struct atmio16d_private *devpriv = dev->private;
 306         struct comedi_cmd *cmd = &s->async->cmd;
 307         unsigned int timer, base_clock;
 308         unsigned int sample_count, tmp, chan, gain;
 309         int i;
 310
 311         /* This is slowly becoming a working command interface. *
 312          * It is still uber-experimental */
 313
 314         reset_counters(dev);
 315         s->async->cur_chan = 0;
 316
 317         /* check if scanning multiple channels */
 318         if (cmd->chanlist_len < 2) {
 319                 devpriv->com_reg_1_state &= ~COMREG1_SCANEN;
 320                 outw(devpriv->com_reg_1_state, dev->iobase + COM_REG_1);
 321         } else {
 322                 devpriv->com_reg_1_state |= COMREG1_SCANEN;
 323                 devpriv->com_reg_2_state |= COMREG2_SCN2;
 324                 outw(devpriv->com_reg_1_state, dev->iobase + COM_REG_1);
 325                 outw(devpriv->com_reg_2_state, dev->iobase + COM_REG_2);
 326         }
 327
 328         /* Setup the Mux-Gain Counter */
 329         for (i = 0; i < cmd->chanlist_len; ++i) {
 330                 chan = CR_CHAN(cmd->chanlist[i]);
 331                 gain = CR_RANGE(cmd->chanlist[i]);
 332                 outw(i, dev->iobase + MUX_CNTR_REG);
 333                 tmp = chan | (gain << 6);
 334                 if (i == cmd->scan_end_arg - 1)
 335                         tmp |= 0x0010;  /* set LASTONE bit */
 336                 outw(tmp, dev->iobase + MUX_GAIN_REG);
 337         }
 338
 339         /* Now program the sample interval timer */
 340         /* Figure out which clock to use then get an
 341          * appropriate timer value */
 342         if (cmd->convert_arg < 65536000) {
 343                 base_clock = CLOCK_1_MHZ;
 344                 timer = cmd->convert_arg / 1000;
 345         } else if (cmd->convert_arg < 655360000) {
 346                 base_clock = CLOCK_100_KHZ;
 347                 timer = cmd->convert_arg / 10000;
 348         } else if (cmd->convert_arg <= 0xffffffff /* 6553600000 */) {
 349                 base_clock = CLOCK_10_KHZ;
 350                 timer = cmd->convert_arg / 100000;
 351         } else if (cmd->convert_arg <= 0xffffffff /* 65536000000 */) {
 352                 base_clock = CLOCK_1_KHZ;
 353                 timer = cmd->convert_arg / 1000000;
 354         }
 355         outw(0xFF03, dev->iobase + AM9513A_COM_REG);
 356         outw(base_clock, dev->iobase + AM9513A_DATA_REG);
 357         outw(0xFF0B, dev->iobase + AM9513A_COM_REG);
 358         outw(0x2, dev->iobase + AM9513A_DATA_REG);
 359         outw(0xFF44, dev->iobase + AM9513A_COM_REG);
 360         outw(0xFFF3, dev->iobase + AM9513A_COM_REG);
 361         outw(timer, dev->iobase + AM9513A_DATA_REG);
 362         outw(0xFF24, dev->iobase + AM9513A_COM_REG);
 363
 364         /* Now figure out how many samples to get */
 365         /* and program the sample counter */
 366         sample_count = cmd->stop_arg * cmd->scan_end_arg;
 367         outw(0xFF04, dev->iobase + AM9513A_COM_REG);
 368         outw(0x1025, dev->iobase + AM9513A_DATA_REG);
 369         outw(0xFF0C, dev->iobase + AM9513A_COM_REG);
 370         if (sample_count < 65536) {
 371                 /* use only Counter 4 */
 372                 outw(sample_count, dev->iobase + AM9513A_DATA_REG);
 373                 outw(0xFF48, dev->iobase + AM9513A_COM_REG);
 374                 outw(0xFFF4, dev->iobase + AM9513A_COM_REG);
 375                 outw(0xFF28, dev->iobase + AM9513A_COM_REG);
 376                 devpriv->com_reg_1_state &= ~COMREG1_1632CNT;
 377                 outw(devpriv->com_reg_1_state, dev->iobase + COM_REG_1);
 378         } else {
 379                 /* Counter 4 and 5 are needed */
 380
 381                 tmp = sample_count & 0xFFFF;
 382                 if (tmp)
 383                         outw(tmp - 1, dev->iobase + AM9513A_DATA_REG);
 384                 else
 385                         outw(0xFFFF, dev->iobase + AM9513A_DATA_REG);
 386
 387                 outw(0xFF48, dev->iobase + AM9513A_COM_REG);
 388                 outw(0, dev->iobase + AM9513A_DATA_REG);
 389                 outw(0xFF28, dev->iobase + AM9513A_COM_REG);
 390                 outw(0xFF05, dev->iobase + AM9513A_COM_REG);
 391                 outw(0x25, dev->iobase + AM9513A_DATA_REG);
 392                 outw(0xFF0D, dev->iobase + AM9513A_COM_REG);
 393                 tmp = sample_count & 0xFFFF;
 394                 if ((tmp == 0) || (tmp == 1)) {
 395                         outw((sample_count >> 16) & 0xFFFF,
 396                              dev->iobase + AM9513A_DATA_REG);
 397                 } else {
 398                         outw(((sample_count >> 16) & 0xFFFF) + 1,
 399                              dev->iobase + AM9513A_DATA_REG);
 400                 }
 401                 outw(0xFF70, dev->iobase + AM9513A_COM_REG);
 402                 devpriv->com_reg_1_state |= COMREG1_1632CNT;
 403                 outw(devpriv->com_reg_1_state, dev->iobase + COM_REG_1);
 404         }
 405
 406         /* Program the scan interval timer ONLY IF SCANNING IS ENABLED */
 407         /* Figure out which clock to use then get an
 408          * appropriate timer value */
 409         if (cmd->chanlist_len > 1) {
 410                 if (cmd->scan_begin_arg < 65536000) {
 411                         base_clock = CLOCK_1_MHZ;
 412                         timer = cmd->scan_begin_arg / 1000;
 413                 } else if (cmd->scan_begin_arg < 655360000) {
 414                         base_clock = CLOCK_100_KHZ;
 415                         timer = cmd->scan_begin_arg / 10000;
 416                 } else if (cmd->scan_begin_arg < 0xffffffff /* 6553600000 */) {
 417                         base_clock = CLOCK_10_KHZ;
 418                         timer = cmd->scan_begin_arg / 100000;
 419                 } else if (cmd->scan_begin_arg < 0xffffffff /* 65536000000 */) {
 420                         base_clock = CLOCK_1_KHZ;
 421                         timer = cmd->scan_begin_arg / 1000000;
 422                 }
 423                 outw(0xFF02, dev->iobase + AM9513A_COM_REG);
 424                 outw(base_clock, dev->iobase + AM9513A_DATA_REG);
 425                 outw(0xFF0A, dev->iobase + AM9513A_COM_REG);
 426                 outw(0x2, dev->iobase + AM9513A_DATA_REG);
 427                 outw(0xFF42, dev->iobase + AM9513A_COM_REG);
 428                 outw(0xFFF2, dev->iobase + AM9513A_COM_REG);
 429                 outw(timer, dev->iobase + AM9513A_DATA_REG);
 430                 outw(0xFF22, dev->iobase + AM9513A_COM_REG);
 431         }
 432
 433         /* Clear the A/D FIFO and reset the MUX counter */
 434         outw(0, dev->iobase + AD_CLEAR_REG);
 435         outw(0, dev->iobase + MUX_CNTR_REG);
 436         outw(0, dev->iobase + INT2CLR_REG);
 437         /* enable this acquisition operation */
 438         devpriv->com_reg_1_state |= COMREG1_DAQEN;
 439         outw(devpriv->com_reg_1_state, dev->iobase + COM_REG_1);
 440         /* enable interrupts for conversion completion */
 441         devpriv->com_reg_1_state |= COMREG1_CONVINTEN;
 442         devpriv->com_reg_2_state |= COMREG2_INTEN;
 443         outw(devpriv->com_reg_1_state, dev->iobase + COM_REG_1);
 444         outw(devpriv->com_reg_2_state, dev->iobase + COM_REG_2);
 445         /* apply a trigger. this starts the counters! */
 446         outw(0, dev->iobase + START_DAQ_REG);
 447
 448         return 0;
 449 }
 450
 451 /* This will cancel a running acquisition operation */
 452 static int atmio16d_ai_cancel(struct comedi_device *dev,
 453                               struct comedi_subdevice *s)
 454 {
 455         reset_atmio16d(dev);
 456
 457         return 0;
 458 }
 459
 460 /* Mode 0 is used to get a single conversion on demand */
 461 static int atmio16d_ai_insn_read(struct comedi_device *dev,
 462                                  struct comedi_subdevice *s,
 463                                  struct comedi_insn *insn, unsigned int *data)
 464 {
 465         struct atmio16d_private *devpriv = dev->private;
 466         int i, t;
 467         int chan;
 468         int gain;
 469         int status;
 470
 471         chan = CR_CHAN(insn->chanspec);
 472         gain = CR_RANGE(insn->chanspec);
 473
 474         /* reset the Analog input circuitry */
 475         /* outw( 0, dev->iobase+AD_CLEAR_REG ); */
 476         /* reset the Analog Input MUX Counter to 0 */
 477         /* outw( 0, dev->iobase+MUX_CNTR_REG ); */
 478
 479         /* set the Input MUX gain */
 480         outw(chan | (gain << 6), dev->iobase + MUX_GAIN_REG);
 481
 482         for (i = 0; i < insn->n; i++) {
 483                 /* start the conversion */
 484                 outw(0, dev->iobase + START_CONVERT_REG);
 485                 /* wait for it to finish */
 486                 for (t = 0; t < ATMIO16D_TIMEOUT; t++) {
 487                         /* check conversion status */
 488                         status = inw(dev->iobase + STAT_REG);
 489                         if (status & STAT_AD_CONVAVAIL) {
 490                                 /* read the data now */
 491                                 data[i] = inw(dev->iobase + AD_FIFO_REG);
 492                                 /* change to two's complement if need be */
 493                                 if (devpriv->adc_coding == adc_2comp)
 494                                         data[i] ^= 0x800;
 495                                 break;
 496                         }
 497                         if (status & STAT_AD_OVERFLOW) {
 498                                 printk(KERN_INFO "atmio16d: a/d FIFO overflow\n");
 499                                 outw(0, dev->iobase + AD_CLEAR_REG);
 500
 501                                 return -ETIME;
 502                         }
 503                 }
 504                 /* end waiting, now check if it timed out */
 505                 if (t == ATMIO16D_TIMEOUT) {
 506                         printk(KERN_INFO "atmio16d: timeout\n");
 507
 508                         return -ETIME;
 509                 }
 510         }
 511
 512         return i;
 513 }
 514
 515 static int atmio16d_ao_insn_read(struct comedi_device *dev,
 516                                  struct comedi_subdevice *s,
 517                                  struct comedi_insn *insn, unsigned int *data)
 518 {
 519         struct atmio16d_private *devpriv = dev->private;
 520         int i;
 521
 522         for (i = 0; i < insn->n; i++)
 523                 data[i] = devpriv->ao_readback[CR_CHAN(insn->chanspec)];
 524         return i;
 525 }
 526
 527 static int atmio16d_ao_insn_write(struct comedi_device *dev,
 528                                   struct comedi_subdevice *s,
 529                                   struct comedi_insn *insn, unsigned int *data)
 530 {
 531         struct atmio16d_private *devpriv = dev->private;
 532         int i;
 533         int chan;
 534         int d;
 535
 536         chan = CR_CHAN(insn->chanspec);
 537
 538         for (i = 0; i < insn->n; i++) {
 539                 d = data[i];
 540                 switch (chan) {
 541                 case 0:
 542                         if (devpriv->dac0_coding == dac_2comp)
 543                                 d ^= 0x800;
 544                         outw(d, dev->iobase + DAC0_REG);
 545                         break;
 546                 case 1:
 547                         if (devpriv->dac1_coding == dac_2comp)
 548                                 d ^= 0x800;
 549                         outw(d, dev->iobase + DAC1_REG);
 550                         break;
 551                 default:
 552                         return -EINVAL;
 553                 }
 554                 devpriv->ao_readback[chan] = data[i];
 555         }
 556         return i;
 557 }
 558
 559 static int atmio16d_dio_insn_bits(struct comedi_device *dev,
 560                                   struct comedi_subdevice *s,
 561                                   struct comedi_insn *insn, unsigned int *data)
 562 {
 563         if (data[0]) {
 564                 s->state &= ~data[0];
 565                 s->state |= (data[0] | data[1]);
 566                 outw(s->state, dev->iobase + MIO_16_DIG_OUT_REG);
 567         }
 568         data[1] = inw(dev->iobase + MIO_16_DIG_IN_REG);
 569
 570         return insn->n;
 571 }
 572
 573 static int atmio16d_dio_insn_config(struct comedi_device *dev,
 574                                     struct comedi_subdevice *s,
 575                                     struct comedi_insn *insn,
 576                                     unsigned int *data)
 577 {
 578         struct atmio16d_private *devpriv = dev->private;
 579         unsigned int chan = CR_CHAN(insn->chanspec);
 580         unsigned int mask;
 581         int ret;
 582
 583         if (chan < 4)
 584                 mask = 0x0f;
 585         else
 586                 mask = 0xf0;
 587
 588         ret = comedi_dio_insn_config(dev, s, insn, data, mask);
 589         if (ret)
 590                 return ret;
 591
 592         devpriv->com_reg_2_state &= ~(COMREG2_DOUTEN0 | COMREG2_DOUTEN1);
 593         if (s->io_bits & 0x0f)
 594                 devpriv->com_reg_2_state |= COMREG2_DOUTEN0;
 595         if (s->io_bits & 0xf0)
 596                 devpriv->com_reg_2_state |= COMREG2_DOUTEN1;
 597         outw(devpriv->com_reg_2_state, dev->iobase + COM_REG_2);
 598
 599         return insn->n;
 600 }
 601
 602 /*
 603    options[0] - I/O port
 604    options[1] - MIO irq
 605                 0 == no irq
 606                 N == irq N {3,4,5,6,7,9,10,11,12,14,15}
 607    options[2] - DIO irq
 608                 0 == no irq
 609                 N == irq N {3,4,5,6,7,9}
 610    options[3] - DMA1 channel
 611                 0 == no DMA
 612                 N == DMA N {5,6,7}
 613    options[4] - DMA2 channel
 614                 0 == no DMA
 615                 N == DMA N {5,6,7}
 616
 617    options[5] - a/d mux
 618         0=differential, 1=single
 619    options[6] - a/d range
 620         0=bipolar10, 1=bipolar5, 2=unipolar10
 621
 622    options[7] - dac0 range
 623         0=bipolar, 1=unipolar
 624    options[8] - dac0 reference
 625         0=internal, 1=external
 626    options[9] - dac0 coding
 627         0=2's comp, 1=straight binary
 628
 629    options[10] - dac1 range
 630    options[11] - dac1 reference
 631    options[12] - dac1 coding
 632  */
 633
 634 static int atmio16d_attach(struct comedi_device *dev,
 635                            struct comedi_devconfig *it)
 636 {
 637         const struct atmio16_board_t *board = comedi_board(dev);
 638         struct atmio16d_private *devpriv;
 639         struct comedi_subdevice *s;
 640         unsigned int irq;
 641         int ret;
 642
 643         ret = comedi_request_region(dev, it->options[0], ATMIO16D_SIZE);
 644         if (ret)
 645                 return ret;
 646
 647         ret = comedi_alloc_subdevices(dev, 4);
 648         if (ret)
 649                 return ret;
 650
 651         devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
 652         if (!devpriv)
 653                 return -ENOMEM;
 654
 655         /* reset the atmio16d hardware */
 656         reset_atmio16d(dev);
 657
 658         /* check if our interrupt is available and get it */
 659         irq = it->options[1];
 660         if (irq) {
 661
 662                 ret = request_irq(irq, atmio16d_interrupt, 0, "atmio16d", dev);
 663                 if (ret < 0) {
 664                         printk(KERN_INFO "failed to allocate irq %u\n", irq);
 665                         return ret;
 666                 }
 667                 dev->irq = irq;
 668                 printk(KERN_INFO "( irq = %u )\n", irq);
 669         } else {
 670                 printk(KERN_INFO "( no irq )");
 671         }
 672
 673         /* set device options */
 674         devpriv->adc_mux = it->options[5];
 675         devpriv->adc_range = it->options[6];
 676
 677         devpriv->dac0_range = it->options[7];
 678         devpriv->dac0_reference = it->options[8];
 679         devpriv->dac0_coding = it->options[9];
 680         devpriv->dac1_range = it->options[10];
 681         devpriv->dac1_reference = it->options[11];
 682         devpriv->dac1_coding = it->options[12];
 683
 684         /* setup sub-devices */
 685         s = &dev->subdevices[0];
 686         dev->read_subdev = s;
 687         /* ai subdevice */
 688         s->type = COMEDI_SUBD_AI;
 689         s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_CMD_READ;
 690         s->n_chan = (devpriv->adc_mux ? 16 : 8);
 691         s->len_chanlist = 16;
 692         s->insn_read = atmio16d_ai_insn_read;
 693         s->do_cmdtest = atmio16d_ai_cmdtest;
 694         s->do_cmd = atmio16d_ai_cmd;
 695         s->cancel = atmio16d_ai_cancel;
 696         s->maxdata = 0xfff;     /* 4095 decimal */
 697         switch (devpriv->adc_range) {
 698         case adc_bipolar10:
 699                 s->range_table = &range_atmio16d_ai_10_bipolar;
 700                 break;
 701         case adc_bipolar5:
 702                 s->range_table = &range_atmio16d_ai_5_bipolar;
 703                 break;
 704         case adc_unipolar10:
 705                 s->range_table = &range_atmio16d_ai_unipolar;
 706                 break;
 707         }
 708
 709         /* ao subdevice */
 710         s = &dev->subdevices[1];
 711         s->type = COMEDI_SUBD_AO;
 712         s->subdev_flags = SDF_WRITABLE;
 713         s->n_chan = 2;
 714         s->insn_read = atmio16d_ao_insn_read;
 715         s->insn_write = atmio16d_ao_insn_write;
 716         s->maxdata = 0xfff;     /* 4095 decimal */
 717         s->range_table_list = devpriv->ao_range_type_list;
 718         switch (devpriv->dac0_range) {
 719         case dac_bipolar:
 720                 devpriv->ao_range_type_list[0] = &range_bipolar10;
 721                 break;
 722         case dac_unipolar:
 723                 devpriv->ao_range_type_list[0] = &range_unipolar10;
 724                 break;
 725         }
 726         switch (devpriv->dac1_range) {
 727         case dac_bipolar:
 728                 devpriv->ao_range_type_list[1] = &range_bipolar10;
 729                 break;
 730         case dac_unipolar:
 731                 devpriv->ao_range_type_list[1] = &range_unipolar10;
 732                 break;
 733         }
 734
 735         /* Digital I/O */
 736         s = &dev->subdevices[2];
 737         s->type = COMEDI_SUBD_DIO;
 738         s->subdev_flags = SDF_WRITABLE | SDF_READABLE;
 739         s->n_chan = 8;
 740         s->insn_bits = atmio16d_dio_insn_bits;
 741         s->insn_config = atmio16d_dio_insn_config;
 742         s->maxdata = 1;
 743         s->range_table = &range_digital;
 744
 745         /* 8255 subdevice */
 746         s = &dev->subdevices[3];
 747         if (board->has_8255)
 748                 subdev_8255_init(dev, s, NULL, dev->iobase);
 749         else
 750                 s->type = COMEDI_SUBD_UNUSED;
 751
 752 /* don't yet know how to deal with counter/timers */
 753 #if 0
 754         s = &dev->subdevices[4];
 755         /* do */
 756         s->type = COMEDI_SUBD_TIMER;
 757         s->n_chan = 0;
 758         s->maxdata = 0
 759 #endif
 760             printk("\n");
 761
 762         return 0;
 763 }
 764
 765 static void atmio16d_detach(struct comedi_device *dev)
 766 {
 767         reset_atmio16d(dev);
 768         comedi_legacy_detach(dev);
 769 }
 770
 771 static const struct atmio16_board_t atmio16_boards[] = {
 772         {
 773                 .name           = "atmio16",
 774                 .has_8255       = 0,
 775         }, {
 776                 .name           = "atmio16d",
 777                 .has_8255       = 1,
 778         },
 779 };
 780
 781 static struct comedi_driver atmio16d_driver = {
 782         .driver_name    = "atmio16",
 783         .module         = THIS_MODULE,
 784         .attach         = atmio16d_attach,
 785         .detach         = atmio16d_detach,
 786         .board_name     = &atmio16_boards[0].name,
 787         .num_names      = ARRAY_SIZE(atmio16_boards),
 788         .offset         = sizeof(struct atmio16_board_t),
 789 };
 790 module_comedi_driver(atmio16d_driver);
 791
 792 MODULE_AUTHOR("Comedi http://www.comedi.org");
 793 MODULE_DESCRIPTION("Comedi low-level driver");
 794 MODULE_LICENSE("GPL");