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