drivers/staging/comedi/drivers/das16.c

   1 /*
   2     comedi/drivers/das16.c
   3     DAS16 driver
   4
   5     COMEDI - Linux Control and Measurement Device Interface
   6     Copyright (C) 2000 David A. Schleef <ds@schleef.org>
   7     Copyright (C) 2000 Chris R. Baugher <baugher@enteract.com>
   8     Copyright (C) 2001,2002 Frank Mori Hess <fmhess@users.sourceforge.net>
   9
  10     This program is free software; you can redistribute it and/or modify
  11     it under the terms of the GNU General Public License as published by
  12     the Free Software Foundation; either version 2 of the License, or
  13     (at your option) any later version.
  14
  15     This program is distributed in the hope that it will be useful,
  16     but WITHOUT ANY WARRANTY; without even the implied warranty of
  17     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18     GNU General Public License for more details.
  19 */
  20 /*
  21 Driver: das16
  22 Description: DAS16 compatible boards
  23 Author: Sam Moore, Warren Jasper, ds, Chris Baugher, Frank Hess, Roman Fietze
  24 Devices: [Keithley Metrabyte] DAS-16 (das-16), DAS-16G (das-16g),
  25   DAS-16F (das-16f), DAS-1201 (das-1201), DAS-1202 (das-1202),
  26   DAS-1401 (das-1401), DAS-1402 (das-1402), DAS-1601 (das-1601),
  27   DAS-1602 (das-1602),
  28   [ComputerBoards] PC104-DAS16/JR (pc104-das16jr),
  29   PC104-DAS16JR/16 (pc104-das16jr/16),
  30   CIO-DAS16JR/16 (cio-das16jr/16),
  31   CIO-DAS16/JR (cio-das16/jr), CIO-DAS1401/12 (cio-das1401/12),
  32   CIO-DAS1402/12 (cio-das1402/12), CIO-DAS1402/16 (cio-das1402/16),
  33   CIO-DAS1601/12 (cio-das1601/12), CIO-DAS1602/12 (cio-das1602/12),
  34   CIO-DAS1602/16 (cio-das1602/16), CIO-DAS16/330 (cio-das16/330)
  35 Status: works
  36 Updated: 2003-10-12
  37
  38 A rewrite of the das16 and das1600 drivers.
  39 Options:
  40         [0] - base io address
  41         [1] - irq (does nothing, irq is not used anymore)
  42         [2] - dma (optional, required for comedi_command support)
  43         [3] - master clock speed in MHz (optional, 1 or 10, ignored if
  44                 board can probe clock, defaults to 1)
  45         [4] - analog input range lowest voltage in microvolts (optional,
  46                 only useful if your board does not have software
  47                 programmable gain)
  48         [5] - analog input range highest voltage in microvolts (optional,
  49                 only useful if board does not have software programmable
  50                 gain)
  51         [6] - analog output range lowest voltage in microvolts (optional)
  52         [7] - analog output range highest voltage in microvolts (optional)
  53         [8] - use timer mode for DMA.  Timer mode is needed e.g. for
  54                 buggy DMA controllers in NS CS5530A (Geode Companion), and for
  55                 'jr' cards that lack a hardware fifo.  This option is no
  56                 longer needed, since timer mode is _always_ used.
  57
  58 Passing a zero for an option is the same as leaving it unspecified.
  59
  60 */
  61 /*
  62
  63 Testing and debugging help provided by Daniel Koch.
  64
  65 Keithley Manuals:
  66         2309.PDF (das16)
  67         4919.PDF (das1400, 1600)
  68         4922.PDF (das-1400)
  69         4923.PDF (das1200, 1400, 1600)
  70
  71 Computer boards manuals also available from their website
  72 www.measurementcomputing.com
  73
  74 */
  75
  76 #include <linux/pci.h>
  77 #include <linux/slab.h>
  78 #include <linux/interrupt.h>
  79
  80 #include <asm/dma.h>
  81
  82 #include "../comedidev.h"
  83
  84 #include "8253.h"
  85 #include "8255.h"
  86 #include "comedi_fc.h"
  87
  88 #undef DEBUG
  89 /* #define DEBUG */
  90
  91 #ifdef DEBUG
  92 #define DEBUG_PRINT(format, args...)    \
  93         printk(KERN_DEBUG "das16: " format, ## args)
  94 #else
  95 #define DEBUG_PRINT(format, args...)
  96 #endif
  97
  98 #define DAS16_SIZE 20           /*  number of ioports */
  99 #define DAS16_DMA_SIZE 0xff00   /*  size in bytes of allocated dma buffer */
 100
 101 /*
 102     cio-das16.pdf
 103
 104     "das16"
 105     "das16/f"
 106
 107   0     a/d bits 0-3            start 12 bit
 108   1     a/d bits 4-11           unused
 109   2     mux read                mux set
 110   3     di 4 bit                do 4 bit
 111   4     unused                  ao0_lsb
 112   5     unused                  ao0_msb
 113   6     unused                  ao1_lsb
 114   7     unused                  ao1_msb
 115   8     status eoc uni/bip      interrupt reset
 116   9     dma, int, trig ctrl     set dma, int
 117   a     pacer control           unused
 118   b     reserved                reserved
 119   cdef  8254
 120   0123  8255
 121
 122 */
 123
 124 /*
 125     cio-das16jr.pdf
 126
 127     "das16jr"
 128
 129   0     a/d bits 0-3            start 12 bit
 130   1     a/d bits 4-11           unused
 131   2     mux read                mux set
 132   3     di 4 bit                do 4 bit
 133   4567  unused                  unused
 134   8     status eoc uni/bip      interrupt reset
 135   9     dma, int, trig ctrl     set dma, int
 136   a     pacer control           unused
 137   b     gain status             gain control
 138   cdef  8254
 139
 140 */
 141
 142 /*
 143     cio-das16jr_16.pdf
 144
 145     "das16jr_16"
 146
 147   0     a/d bits 0-7            start 16 bit
 148   1     a/d bits 8-15           unused
 149   2     mux read                mux set
 150   3     di 4 bit                do 4 bit
 151   4567  unused                  unused
 152   8     status eoc uni/bip      interrupt reset
 153   9     dma, int, trig ctrl     set dma, int
 154   a     pacer control           unused
 155   b     gain status             gain control
 156   cdef  8254
 157
 158 */
 159 /*
 160     cio-das160x-1x.pdf
 161
 162     "das1601/12"
 163     "das1602/12"
 164     "das1602/16"
 165
 166   0     a/d bits 0-3            start 12 bit
 167   1     a/d bits 4-11           unused
 168   2     mux read                mux set
 169   3     di 4 bit                do 4 bit
 170   4     unused                  ao0_lsb
 171   5     unused                  ao0_msb
 172   6     unused                  ao1_lsb
 173   7     unused                  ao1_msb
 174   8     status eoc uni/bip      interrupt reset
 175   9     dma, int, trig ctrl     set dma, int
 176   a     pacer control           unused
 177   b     gain status             gain control
 178   cdef  8254
 179   400   8255
 180   404   unused                  conversion enable
 181   405   unused                  burst enable
 182   406   unused                  das1600 enable
 183   407   status
 184
 185 */
 186
 187 /*  size in bytes of a sample from board */
 188 static const int sample_size = 2;
 189
 190 #define DAS16_TRIG              0
 191 #define DAS16_AI_LSB            0
 192 #define DAS16_AI_MSB            1
 193 #define DAS16_MUX               2
 194 #define DAS16_DIO               3
 195 #define DAS16_AO_LSB(x) ((x) ? 6 : 4)
 196 #define DAS16_AO_MSB(x) ((x) ? 7 : 5)
 197 #define DAS16_STATUS            8
 198 #define   BUSY                  (1<<7)
 199 #define   UNIPOLAR                      (1<<6)
 200 #define   DAS16_MUXBIT                  (1<<5)
 201 #define   DAS16_INT                     (1<<4)
 202 #define DAS16_CONTROL           9
 203 #define   DAS16_INTE                    (1<<7)
 204 #define   DAS16_IRQ(x)                  (((x) & 0x7) << 4)
 205 #define   DMA_ENABLE                    (1<<2)
 206 #define   PACING_MASK   0x3
 207 #define   INT_PACER             0x03
 208 #define   EXT_PACER                     0x02
 209 #define   DAS16_SOFT            0x00
 210 #define DAS16_PACER             0x0A
 211 #define   DAS16_CTR0                    (1<<1)
 212 #define   DAS16_TRIG0                   (1<<0)
 213 #define   BURST_LEN_BITS(x)                     (((x) & 0xf) << 4)
 214 #define DAS16_GAIN              0x0B
 215 #define DAS16_CNTR0_DATA                0x0C
 216 #define DAS16_CNTR1_DATA                0x0D
 217 #define DAS16_CNTR2_DATA                0x0E
 218 #define DAS16_CNTR_CONTROL      0x0F
 219 #define   DAS16_TERM_CNT        0x00
 220 #define   DAS16_ONE_SHOT        0x02
 221 #define   DAS16_RATE_GEN        0x04
 222 #define   DAS16_CNTR_LSB_MSB    0x30
 223 #define   DAS16_CNTR0           0x00
 224 #define   DAS16_CNTR1           0x40
 225 #define   DAS16_CNTR2           0x80
 226
 227 #define DAS1600_CONV            0x404
 228 #define   DAS1600_CONV_DISABLE          0x40
 229 #define DAS1600_BURST           0x405
 230 #define   DAS1600_BURST_VAL             0x40
 231 #define DAS1600_ENABLE          0x406
 232 #define   DAS1600_ENABLE_VAL            0x40
 233 #define DAS1600_STATUS_B        0x407
 234 #define   DAS1600_BME           0x40
 235 #define   DAS1600_ME            0x20
 236 #define   DAS1600_CD                    0x10
 237 #define   DAS1600_WS                    0x02
 238 #define   DAS1600_CLK_10MHZ             0x01
 239
 240 static const struct comedi_lrange range_das1x01_bip = { 4, {
 241                                                             BIP_RANGE(10),
 242                                                             BIP_RANGE(1),
 243                                                             BIP_RANGE(0.1),
 244                                                             BIP_RANGE(0.01),
 245                                                             }
 246 };
 247
 248 static const struct comedi_lrange range_das1x01_unip = { 4, {
 249                                                              UNI_RANGE(10),
 250                                                              UNI_RANGE(1),
 251                                                              UNI_RANGE(0.1),
 252                                                              UNI_RANGE(0.01),
 253                                                              }
 254 };
 255
 256 static const struct comedi_lrange range_das1x02_bip = { 4, {
 257                                                             BIP_RANGE(10),
 258                                                             BIP_RANGE(5),
 259                                                             BIP_RANGE(2.5),
 260                                                             BIP_RANGE(1.25),
 261                                                             }
 262 };
 263
 264 static const struct comedi_lrange range_das1x02_unip = { 4, {
 265                                                              UNI_RANGE(10),
 266                                                              UNI_RANGE(5),
 267                                                              UNI_RANGE(2.5),
 268                                                              UNI_RANGE(1.25),
 269                                                              }
 270 };
 271
 272 static const struct comedi_lrange range_das16jr = { 9, {
 273                                                 /*  also used by 16/330 */
 274                                                         BIP_RANGE(10),
 275                                                         BIP_RANGE(5),
 276                                                         BIP_RANGE(2.5),
 277                                                         BIP_RANGE(1.25),
 278                                                         BIP_RANGE(0.625),
 279                                                         UNI_RANGE(10),
 280                                                         UNI_RANGE(5),
 281                                                         UNI_RANGE(2.5),
 282                                                         UNI_RANGE(1.25),
 283                                                         }
 284 };
 285
 286 static const struct comedi_lrange range_das16jr_16 = { 8, {
 287                                                            BIP_RANGE(10),
 288                                                            BIP_RANGE(5),
 289                                                            BIP_RANGE(2.5),
 290                                                            BIP_RANGE(1.25),
 291                                                            UNI_RANGE(10),
 292                                                            UNI_RANGE(5),
 293                                                            UNI_RANGE(2.5),
 294                                                            UNI_RANGE(1.25),
 295                                                            }
 296 };
 297
 298 static const int das16jr_gainlist[] = { 8, 0, 1, 2, 3, 4, 5, 6, 7 };
 299 static const int das16jr_16_gainlist[] = { 0, 1, 2, 3, 4, 5, 6, 7 };
 300 static const int das1600_gainlist[] = { 0, 1, 2, 3 };
 301
 302 enum {
 303         das16_pg_none = 0,
 304         das16_pg_16jr,
 305         das16_pg_16jr_16,
 306         das16_pg_1601,
 307         das16_pg_1602,
 308 };
 309 static const int *const das16_gainlists[] = {
 310         NULL,
 311         das16jr_gainlist,
 312         das16jr_16_gainlist,
 313         das1600_gainlist,
 314         das1600_gainlist,
 315 };
 316
 317 static const struct comedi_lrange *const das16_ai_uni_lranges[] = {
 318         &range_unknown,
 319         &range_das16jr,
 320         &range_das16jr_16,
 321         &range_das1x01_unip,
 322         &range_das1x02_unip,
 323 };
 324
 325 static const struct comedi_lrange *const das16_ai_bip_lranges[] = {
 326         &range_unknown,
 327         &range_das16jr,
 328         &range_das16jr_16,
 329         &range_das1x01_bip,
 330         &range_das1x02_bip,
 331 };
 332
 333 struct munge_info {
 334         uint8_t byte;
 335         unsigned have_byte:1;
 336 };
 337
 338 struct das16_board {
 339         const char *name;
 340         void *ai;
 341         unsigned int ai_nbits;
 342         unsigned int ai_speed;  /*  max conversion speed in nanosec */
 343         unsigned int ai_pg;
 344         void *ao;
 345         unsigned int ao_nbits;
 346         void *di;
 347         void *do_;
 348
 349         unsigned int i8255_offset;
 350         unsigned int i8254_offset;
 351
 352         unsigned int size;
 353         unsigned int id;
 354 };
 355
 356 #define DAS16_TIMEOUT 1000
 357
 358 /* Period for timer interrupt in jiffies.  It's a function
 359  * to deal with possibility of dynamic HZ patches  */
 360 static inline int timer_period(void)
 361 {
 362         return HZ / 20;
 363 }
 364
 365 struct das16_private_struct {
 366         unsigned int ai_unipolar;       /*  unipolar flag */
 367         unsigned int ai_singleended;    /*  single ended flag */
 368         unsigned int clockbase; /*  master clock speed in ns */
 369         volatile unsigned int control_state;    /*  dma, interrupt and trigger control bits */
 370         volatile unsigned long adc_byte_count;  /*  number of bytes remaining */
 371         /*  divisor dividing master clock to get conversion frequency */
 372         unsigned int divisor1;
 373         /*  divisor dividing master clock to get conversion frequency */
 374         unsigned int divisor2;
 375         unsigned int dma_chan;  /*  dma channel */
 376         uint16_t *dma_buffer[2];
 377         dma_addr_t dma_buffer_addr[2];
 378         unsigned int current_buffer;
 379         volatile unsigned int dma_transfer_size;        /*  target number of bytes to transfer per dma shot */
 380         /**
 381          * user-defined analog input and output ranges
 382          * defined from config options
 383          */
 384         struct comedi_lrange *user_ai_range_table;
 385         struct comedi_lrange *user_ao_range_table;
 386
 387         struct timer_list timer;        /*  for timed interrupt */
 388         volatile short timer_running;
 389         volatile short timer_mode;      /*  true if using timer mode */
 390
 391         unsigned long extra_iobase;
 392 };
 393
 394 static int das16_cmd_test(struct comedi_device *dev, struct comedi_subdevice *s,
 395                           struct comedi_cmd *cmd)
 396 {
 397         const struct das16_board *board = comedi_board(dev);
 398         struct das16_private_struct *devpriv = dev->private;
 399         int err = 0, tmp;
 400         int gain, start_chan, i;
 401         int mask;
 402
 403         /* Step 1 : check if triggers are trivially valid */
 404
 405         err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
 406
 407         mask = TRIG_FOLLOW;
 408         /*  if board supports burst mode */
 409         if (board->size > 0x400)
 410                 mask |= TRIG_TIMER | TRIG_EXT;
 411         err |= cfc_check_trigger_src(&cmd->scan_begin_src, mask);
 412
 413         tmp = cmd->convert_src;
 414         mask = TRIG_TIMER | TRIG_EXT;
 415         /*  if board supports burst mode */
 416         if (board->size > 0x400)
 417                 mask |= TRIG_NOW;
 418         err |= cfc_check_trigger_src(&cmd->convert_src, mask);
 419
 420         err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
 421         err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
 422
 423         if (err)
 424                 return 1;
 425
 426         /* Step 2a : make sure trigger sources are unique */
 427
 428         err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
 429         err |= cfc_check_trigger_is_unique(cmd->convert_src);
 430         err |= cfc_check_trigger_is_unique(cmd->stop_src);
 431
 432         /* Step 2b : and mutually compatible */
 433
 434         /*  make sure scan_begin_src and convert_src dont conflict */
 435         if (cmd->scan_begin_src == TRIG_FOLLOW && cmd->convert_src == TRIG_NOW)
 436                 err |= -EINVAL;
 437         if (cmd->scan_begin_src != TRIG_FOLLOW && cmd->convert_src != TRIG_NOW)
 438                 err |= -EINVAL;
 439
 440         if (err)
 441                 return 2;
 442
 443         /* Step 3: check if arguments are trivially valid */
 444
 445         err |= cfc_check_trigger_arg_is(&cmd->start_arg, 0);
 446
 447         if (cmd->scan_begin_src == TRIG_FOLLOW) /* internal trigger */
 448                 err |= cfc_check_trigger_arg_is(&cmd->scan_begin_arg, 0);
 449
 450         err |= cfc_check_trigger_arg_is(&cmd->scan_end_arg, cmd->chanlist_len);
 451
 452         /* check against maximum frequency */
 453         if (cmd->scan_begin_src == TRIG_TIMER)
 454                 err |= cfc_check_trigger_arg_min(&cmd->scan_begin_arg,
 455                                         board->ai_speed * cmd->chanlist_len);
 456
 457         if (cmd->convert_src == TRIG_TIMER)
 458                 err |= cfc_check_trigger_arg_min(&cmd->convert_arg,
 459                                                  board->ai_speed);
 460
 461         if (cmd->stop_src == TRIG_NONE)
 462                 err |= cfc_check_trigger_arg_is(&cmd->stop_arg, 0);
 463
 464         if (err)
 465                 return 3;
 466
 467         /*  step 4: fix up arguments */
 468         if (cmd->scan_begin_src == TRIG_TIMER) {
 469                 unsigned int tmp = cmd->scan_begin_arg;
 470                 /*  set divisors, correct timing arguments */
 471                 i8253_cascade_ns_to_timer_2div(devpriv->clockbase,
 472                                                &(devpriv->divisor1),
 473                                                &(devpriv->divisor2),
 474                                                &(cmd->scan_begin_arg),
 475                                                cmd->flags & TRIG_ROUND_MASK);
 476                 err += (tmp != cmd->scan_begin_arg);
 477         }
 478         if (cmd->convert_src == TRIG_TIMER) {
 479                 unsigned int tmp = cmd->convert_arg;
 480                 /*  set divisors, correct timing arguments */
 481                 i8253_cascade_ns_to_timer_2div(devpriv->clockbase,
 482                                                &(devpriv->divisor1),
 483                                                &(devpriv->divisor2),
 484                                                &(cmd->convert_arg),
 485                                                cmd->flags & TRIG_ROUND_MASK);
 486                 err += (tmp != cmd->convert_arg);
 487         }
 488         if (err)
 489                 return 4;
 490
 491         /*  check channel/gain list against card's limitations */
 492         if (cmd->chanlist) {
 493                 gain = CR_RANGE(cmd->chanlist[0]);
 494                 start_chan = CR_CHAN(cmd->chanlist[0]);
 495                 for (i = 1; i < cmd->chanlist_len; i++) {
 496                         if (CR_CHAN(cmd->chanlist[i]) !=
 497                             (start_chan + i) % s->n_chan) {
 498                                 comedi_error(dev,
 499                                                 "entries in chanlist must be "
 500                                                 "consecutive channels, "
 501                                                 "counting upwards\n");
 502                                 err++;
 503                         }
 504                         if (CR_RANGE(cmd->chanlist[i]) != gain) {
 505                                 comedi_error(dev,
 506                                                 "entries in chanlist must all "
 507                                                 "have the same gain\n");
 508                                 err++;
 509                         }
 510                 }
 511         }
 512         if (err)
 513                 return 5;
 514
 515         return 0;
 516 }
 517
 518 /* utility function that suggests a dma transfer size in bytes */
 519 static unsigned int das16_suggest_transfer_size(struct comedi_device *dev,
 520                                                 const struct comedi_cmd *cmd)
 521 {
 522         struct das16_private_struct *devpriv = dev->private;
 523         unsigned int size;
 524         unsigned int freq;
 525
 526         /* if we are using timer interrupt, we don't care how long it
 527          * will take to complete transfer since it will be interrupted
 528          * by timer interrupt */
 529         if (devpriv->timer_mode)
 530                 return DAS16_DMA_SIZE;
 531
 532         /* otherwise, we are relying on dma terminal count interrupt,
 533          * so pick a reasonable size */
 534         if (cmd->convert_src == TRIG_TIMER)
 535                 freq = 1000000000 / cmd->convert_arg;
 536         else if (cmd->scan_begin_src == TRIG_TIMER)
 537                 freq = (1000000000 / cmd->scan_begin_arg) * cmd->chanlist_len;
 538         /*  return some default value */
 539         else
 540                 freq = 0xffffffff;
 541
 542         if (cmd->flags & TRIG_WAKE_EOS) {
 543                 size = sample_size * cmd->chanlist_len;
 544         } else {
 545                 /*  make buffer fill in no more than 1/3 second */
 546                 size = (freq / 3) * sample_size;
 547         }
 548
 549         /*  set a minimum and maximum size allowed */
 550         if (size > DAS16_DMA_SIZE)
 551                 size = DAS16_DMA_SIZE - DAS16_DMA_SIZE % sample_size;
 552         else if (size < sample_size)
 553                 size = sample_size;
 554
 555         if (cmd->stop_src == TRIG_COUNT && size > devpriv->adc_byte_count)
 556                 size = devpriv->adc_byte_count;
 557
 558         return size;
 559 }
 560
 561 static unsigned int das16_set_pacer(struct comedi_device *dev, unsigned int ns,
 562                                     int rounding_flags)
 563 {
 564         struct das16_private_struct *devpriv = dev->private;
 565
 566         i8253_cascade_ns_to_timer_2div(devpriv->clockbase, &(devpriv->divisor1),
 567                                        &(devpriv->divisor2), &ns,
 568                                        rounding_flags & TRIG_ROUND_MASK);
 569
 570         /* Write the values of ctr1 and ctr2 into counters 1 and 2 */
 571         i8254_load(dev->iobase + DAS16_CNTR0_DATA, 0, 1, devpriv->divisor1, 2);
 572         i8254_load(dev->iobase + DAS16_CNTR0_DATA, 0, 2, devpriv->divisor2, 2);
 573
 574         return ns;
 575 }
 576
 577 static int das16_cmd_exec(struct comedi_device *dev, struct comedi_subdevice *s)
 578 {
 579         const struct das16_board *board = comedi_board(dev);
 580         struct das16_private_struct *devpriv = dev->private;
 581         struct comedi_async *async = s->async;
 582         struct comedi_cmd *cmd = &async->cmd;
 583         unsigned int byte;
 584         unsigned long flags;
 585         int range;
 586
 587         if (devpriv->dma_chan == 0 || (dev->irq == 0
 588                                        && devpriv->timer_mode == 0)) {
 589                 comedi_error(dev,
 590                                 "irq (or use of 'timer mode') dma required to "
 591                                                         "execute comedi_cmd");
 592                 return -1;
 593         }
 594         if (cmd->flags & TRIG_RT) {
 595                 comedi_error(dev, "isa dma transfers cannot be performed with "
 596                                                         "TRIG_RT, aborting");
 597                 return -1;
 598         }
 599
 600         devpriv->adc_byte_count =
 601             cmd->stop_arg * cmd->chanlist_len * sizeof(uint16_t);
 602
 603         /*  disable conversions for das1600 mode */
 604         if (board->size > 0x400)
 605                 outb(DAS1600_CONV_DISABLE, dev->iobase + DAS1600_CONV);
 606
 607         /*  set scan limits */
 608         byte = CR_CHAN(cmd->chanlist[0]);
 609         byte |= CR_CHAN(cmd->chanlist[cmd->chanlist_len - 1]) << 4;
 610         outb(byte, dev->iobase + DAS16_MUX);
 611
 612         /* set gain (this is also burst rate register but according to
 613          * computer boards manual, burst rate does nothing, even on
 614          * keithley cards) */
 615         if (board->ai_pg != das16_pg_none) {
 616                 range = CR_RANGE(cmd->chanlist[0]);
 617                 outb((das16_gainlists[board->ai_pg])[range],
 618                      dev->iobase + DAS16_GAIN);
 619         }
 620
 621         /* set counter mode and counts */
 622         cmd->convert_arg =
 623             das16_set_pacer(dev, cmd->convert_arg,
 624                             cmd->flags & TRIG_ROUND_MASK);
 625         DEBUG_PRINT("pacer period: %d ns\n", cmd->convert_arg);
 626
 627         /* enable counters */
 628         byte = 0;
 629         /* Enable burst mode if appropriate. */
 630         if (board->size > 0x400) {
 631                 if (cmd->convert_src == TRIG_NOW) {
 632                         outb(DAS1600_BURST_VAL, dev->iobase + DAS1600_BURST);
 633                         /*  set burst length */
 634                         byte |= BURST_LEN_BITS(cmd->chanlist_len - 1);
 635                 } else {
 636                         outb(0, dev->iobase + DAS1600_BURST);
 637                 }
 638         }
 639         outb(byte, dev->iobase + DAS16_PACER);
 640
 641         /*  set up dma transfer */
 642         flags = claim_dma_lock();
 643         disable_dma(devpriv->dma_chan);
 644         /* clear flip-flop to make sure 2-byte registers for
 645          * count and address get set correctly */
 646         clear_dma_ff(devpriv->dma_chan);
 647         devpriv->current_buffer = 0;
 648         set_dma_addr(devpriv->dma_chan,
 649                      devpriv->dma_buffer_addr[devpriv->current_buffer]);
 650         /*  set appropriate size of transfer */
 651         devpriv->dma_transfer_size = das16_suggest_transfer_size(dev, cmd);
 652         set_dma_count(devpriv->dma_chan, devpriv->dma_transfer_size);
 653         enable_dma(devpriv->dma_chan);
 654         release_dma_lock(flags);
 655
 656         /*  set up interrupt */
 657         if (devpriv->timer_mode) {
 658                 devpriv->timer_running = 1;
 659                 devpriv->timer.expires = jiffies + timer_period();
 660                 add_timer(&devpriv->timer);
 661                 devpriv->control_state &= ~DAS16_INTE;
 662         } else {
 663                 /* clear interrupt bit */
 664                 outb(0x00, dev->iobase + DAS16_STATUS);
 665                 /* enable interrupts */
 666                 devpriv->control_state |= DAS16_INTE;
 667         }
 668         devpriv->control_state |= DMA_ENABLE;
 669         devpriv->control_state &= ~PACING_MASK;
 670         if (cmd->convert_src == TRIG_EXT)
 671                 devpriv->control_state |= EXT_PACER;
 672         else
 673                 devpriv->control_state |= INT_PACER;
 674         outb(devpriv->control_state, dev->iobase + DAS16_CONTROL);
 675
 676         /* Enable conversions if using das1600 mode */
 677         if (board->size > 0x400)
 678                 outb(0, dev->iobase + DAS1600_CONV);
 679
 680
 681         return 0;
 682 }
 683
 684 static int das16_cancel(struct comedi_device *dev, struct comedi_subdevice *s)
 685 {
 686         const struct das16_board *board = comedi_board(dev);
 687         struct das16_private_struct *devpriv = dev->private;
 688         unsigned long flags;
 689
 690         spin_lock_irqsave(&dev->spinlock, flags);
 691         /* disable interrupts, dma and pacer clocked conversions */
 692         devpriv->control_state &= ~DAS16_INTE & ~PACING_MASK & ~DMA_ENABLE;
 693         outb(devpriv->control_state, dev->iobase + DAS16_CONTROL);
 694         if (devpriv->dma_chan)
 695                 disable_dma(devpriv->dma_chan);
 696
 697         /*  disable SW timer */
 698         if (devpriv->timer_mode && devpriv->timer_running) {
 699                 devpriv->timer_running = 0;
 700                 del_timer(&devpriv->timer);
 701         }
 702
 703         /* disable burst mode */
 704         if (board->size > 0x400)
 705                 outb(0, dev->iobase + DAS1600_BURST);
 706
 707
 708         spin_unlock_irqrestore(&dev->spinlock, flags);
 709
 710         return 0;
 711 }
 712
 713 static void das16_reset(struct comedi_device *dev)
 714 {
 715         outb(0, dev->iobase + DAS16_STATUS);
 716         outb(0, dev->iobase + DAS16_CONTROL);
 717         outb(0, dev->iobase + DAS16_PACER);
 718         outb(0, dev->iobase + DAS16_CNTR_CONTROL);
 719 }
 720
 721 static int das16_ai_rinsn(struct comedi_device *dev, struct comedi_subdevice *s,
 722                           struct comedi_insn *insn, unsigned int *data)
 723 {
 724         const struct das16_board *board = comedi_board(dev);
 725         struct das16_private_struct *devpriv = dev->private;
 726         int i, n;
 727         int range;
 728         int chan;
 729         int msb, lsb;
 730
 731         /*  disable interrupts and pacing */
 732         devpriv->control_state &= ~DAS16_INTE & ~DMA_ENABLE & ~PACING_MASK;
 733         outb(devpriv->control_state, dev->iobase + DAS16_CONTROL);
 734
 735         /* set multiplexer */
 736         chan = CR_CHAN(insn->chanspec);
 737         chan |= CR_CHAN(insn->chanspec) << 4;
 738         outb(chan, dev->iobase + DAS16_MUX);
 739
 740         /* set gain */
 741         if (board->ai_pg != das16_pg_none) {
 742                 range = CR_RANGE(insn->chanspec);
 743                 outb((das16_gainlists[board->ai_pg])[range],
 744                      dev->iobase + DAS16_GAIN);
 745         }
 746
 747         for (n = 0; n < insn->n; n++) {
 748                 /* trigger conversion */
 749                 outb_p(0, dev->iobase + DAS16_TRIG);
 750
 751                 for (i = 0; i < DAS16_TIMEOUT; i++) {
 752                         if (!(inb(dev->iobase + DAS16_STATUS) & BUSY))
 753                                 break;
 754                 }
 755                 if (i == DAS16_TIMEOUT) {
 756                         printk("das16: timeout\n");
 757                         return -ETIME;
 758                 }
 759                 msb = inb(dev->iobase + DAS16_AI_MSB);
 760                 lsb = inb(dev->iobase + DAS16_AI_LSB);
 761                 if (board->ai_nbits == 12)
 762                         data[n] = ((lsb >> 4) & 0xf) | (msb << 4);
 763                 else
 764                         data[n] = lsb | (msb << 8);
 765
 766         }
 767
 768         return n;
 769 }
 770
 771 static int das16_di_rbits(struct comedi_device *dev, struct comedi_subdevice *s,
 772                           struct comedi_insn *insn, unsigned int *data)
 773 {
 774         unsigned int bits;
 775
 776         bits = inb(dev->iobase + DAS16_DIO) & 0xf;
 777         data[1] = bits;
 778         data[0] = 0;
 779
 780         return insn->n;
 781 }
 782
 783 static int das16_do_wbits(struct comedi_device *dev, struct comedi_subdevice *s,
 784                           struct comedi_insn *insn, unsigned int *data)
 785 {
 786         unsigned int wbits;
 787
 788         /*  only set bits that have been masked */
 789         data[0] &= 0xf;
 790         wbits = s->state;
 791         /*  zero bits that have been masked */
 792         wbits &= ~data[0];
 793         /*  set masked bits */
 794         wbits |= data[0] & data[1];
 795         s->state = wbits;
 796         data[1] = wbits;
 797
 798         outb(s->state, dev->iobase + DAS16_DIO);
 799
 800         return insn->n;
 801 }
 802
 803 static int das16_ao_winsn(struct comedi_device *dev, struct comedi_subdevice *s,
 804                           struct comedi_insn *insn, unsigned int *data)
 805 {
 806         const struct das16_board *board = comedi_board(dev);
 807         int i;
 808         int lsb, msb;
 809         int chan;
 810
 811         chan = CR_CHAN(insn->chanspec);
 812
 813         for (i = 0; i < insn->n; i++) {
 814                 if (board->ao_nbits == 12) {
 815                         lsb = (data[i] << 4) & 0xff;
 816                         msb = (data[i] >> 4) & 0xff;
 817                 } else {
 818                         lsb = data[i] & 0xff;
 819                         msb = (data[i] >> 8) & 0xff;
 820                 }
 821                 outb(lsb, dev->iobase + DAS16_AO_LSB(chan));
 822                 outb(msb, dev->iobase + DAS16_AO_MSB(chan));
 823         }
 824
 825         return i;
 826 }
 827
 828 /* the pc104-das16jr (at least) has problems if the dma
 829         transfer is interrupted in the middle of transferring
 830         a 16 bit sample, so this function takes care to get
 831         an even transfer count after disabling dma
 832         channel.
 833 */
 834 static int disable_dma_on_even(struct comedi_device *dev)
 835 {
 836         struct das16_private_struct *devpriv = dev->private;
 837         int residue;
 838         int i;
 839         static const int disable_limit = 100;
 840         static const int enable_timeout = 100;
 841
 842         disable_dma(devpriv->dma_chan);
 843         residue = get_dma_residue(devpriv->dma_chan);
 844         for (i = 0; i < disable_limit && (residue % 2); ++i) {
 845                 int j;
 846                 enable_dma(devpriv->dma_chan);
 847                 for (j = 0; j < enable_timeout; ++j) {
 848                         int new_residue;
 849                         udelay(2);
 850                         new_residue = get_dma_residue(devpriv->dma_chan);
 851                         if (new_residue != residue)
 852                                 break;
 853                 }
 854                 disable_dma(devpriv->dma_chan);
 855                 residue = get_dma_residue(devpriv->dma_chan);
 856         }
 857         if (i == disable_limit) {
 858                 comedi_error(dev, "failed to get an even dma transfer, "
 859                                                         "could be trouble.");
 860         }
 861         return residue;
 862 }
 863
 864 static void das16_interrupt(struct comedi_device *dev)
 865 {
 866         const struct das16_board *board = comedi_board(dev);
 867         struct das16_private_struct *devpriv = dev->private;
 868         unsigned long dma_flags, spin_flags;
 869         struct comedi_subdevice *s = dev->read_subdev;
 870         struct comedi_async *async;
 871         struct comedi_cmd *cmd;
 872         int num_bytes, residue;
 873         int buffer_index;
 874
 875         if (!dev->attached) {
 876                 comedi_error(dev, "premature interrupt");
 877                 return;
 878         }
 879         /*  initialize async here to make sure it is not NULL */
 880         async = s->async;
 881         cmd = &async->cmd;
 882
 883         if (devpriv->dma_chan == 0) {
 884                 comedi_error(dev, "interrupt with no dma channel?");
 885                 return;
 886         }
 887
 888         spin_lock_irqsave(&dev->spinlock, spin_flags);
 889         if ((devpriv->control_state & DMA_ENABLE) == 0) {
 890                 spin_unlock_irqrestore(&dev->spinlock, spin_flags);
 891                 DEBUG_PRINT("interrupt while dma disabled?\n");
 892                 return;
 893         }
 894
 895         dma_flags = claim_dma_lock();
 896         clear_dma_ff(devpriv->dma_chan);
 897         residue = disable_dma_on_even(dev);
 898
 899         /*  figure out how many points to read */
 900         if (residue > devpriv->dma_transfer_size) {
 901                 comedi_error(dev, "residue > transfer size!\n");
 902                 async->events |= COMEDI_CB_ERROR | COMEDI_CB_EOA;
 903                 num_bytes = 0;
 904         } else
 905                 num_bytes = devpriv->dma_transfer_size - residue;
 906
 907         if (cmd->stop_src == TRIG_COUNT &&
 908                                         num_bytes >= devpriv->adc_byte_count) {
 909                 num_bytes = devpriv->adc_byte_count;
 910                 async->events |= COMEDI_CB_EOA;
 911         }
 912
 913         buffer_index = devpriv->current_buffer;
 914         devpriv->current_buffer = (devpriv->current_buffer + 1) % 2;
 915         devpriv->adc_byte_count -= num_bytes;
 916
 917         /*  figure out how many bytes for next transfer */
 918         if (cmd->stop_src == TRIG_COUNT && devpriv->timer_mode == 0 &&
 919             devpriv->dma_transfer_size > devpriv->adc_byte_count)
 920                 devpriv->dma_transfer_size = devpriv->adc_byte_count;
 921
 922         /*  re-enable  dma */
 923         if ((async->events & COMEDI_CB_EOA) == 0) {
 924                 set_dma_addr(devpriv->dma_chan,
 925                              devpriv->dma_buffer_addr[devpriv->current_buffer]);
 926                 set_dma_count(devpriv->dma_chan, devpriv->dma_transfer_size);
 927                 enable_dma(devpriv->dma_chan);
 928                 /* reenable conversions for das1600 mode, (stupid hardware) */
 929                 if (board->size > 0x400 && devpriv->timer_mode == 0)
 930                         outb(0x00, dev->iobase + DAS1600_CONV);
 931
 932         }
 933         release_dma_lock(dma_flags);
 934
 935         spin_unlock_irqrestore(&dev->spinlock, spin_flags);
 936
 937         cfc_write_array_to_buffer(s,
 938                                   devpriv->dma_buffer[buffer_index], num_bytes);
 939
 940         cfc_handle_events(dev, s);
 941 }
 942
 943 static irqreturn_t das16_dma_interrupt(int irq, void *d)
 944 {
 945         int status;
 946         struct comedi_device *dev = d;
 947
 948         status = inb(dev->iobase + DAS16_STATUS);
 949
 950         if ((status & DAS16_INT) == 0) {
 951                 DEBUG_PRINT("spurious interrupt\n");
 952                 return IRQ_NONE;
 953         }
 954
 955         /* clear interrupt */
 956         outb(0x00, dev->iobase + DAS16_STATUS);
 957         das16_interrupt(dev);
 958         return IRQ_HANDLED;
 959 }
 960
 961 static void das16_timer_interrupt(unsigned long arg)
 962 {
 963         struct comedi_device *dev = (struct comedi_device *)arg;
 964         struct das16_private_struct *devpriv = dev->private;
 965
 966         das16_interrupt(dev);
 967
 968         if (devpriv->timer_running)
 969                 mod_timer(&devpriv->timer, jiffies + timer_period());
 970 }
 971
 972 static void reg_dump(struct comedi_device *dev)
 973 {
 974         DEBUG_PRINT("********DAS1600 REGISTER DUMP********\n");
 975         DEBUG_PRINT("DAS16_MUX: %x\n", inb(dev->iobase + DAS16_MUX));
 976         DEBUG_PRINT("DAS16_DIO: %x\n", inb(dev->iobase + DAS16_DIO));
 977         DEBUG_PRINT("DAS16_STATUS: %x\n", inb(dev->iobase + DAS16_STATUS));
 978         DEBUG_PRINT("DAS16_CONTROL: %x\n", inb(dev->iobase + DAS16_CONTROL));
 979         DEBUG_PRINT("DAS16_PACER: %x\n", inb(dev->iobase + DAS16_PACER));
 980         DEBUG_PRINT("DAS16_GAIN: %x\n", inb(dev->iobase + DAS16_GAIN));
 981         DEBUG_PRINT("DAS16_CNTR_CONTROL: %x\n",
 982                     inb(dev->iobase + DAS16_CNTR_CONTROL));
 983         DEBUG_PRINT("DAS1600_CONV: %x\n", inb(dev->iobase + DAS1600_CONV));
 984         DEBUG_PRINT("DAS1600_BURST: %x\n", inb(dev->iobase + DAS1600_BURST));
 985         DEBUG_PRINT("DAS1600_ENABLE: %x\n", inb(dev->iobase + DAS1600_ENABLE));
 986         DEBUG_PRINT("DAS1600_STATUS_B: %x\n",
 987                     inb(dev->iobase + DAS1600_STATUS_B));
 988 }
 989
 990 static int das16_probe(struct comedi_device *dev, struct comedi_devconfig *it)
 991 {
 992         const struct das16_board *board = comedi_board(dev);
 993         struct das16_private_struct *devpriv = dev->private;
 994         int status;
 995         int diobits;
 996
 997         /* status is available on all boards */
 998
 999         status = inb(dev->iobase + DAS16_STATUS);
1000
1001         if ((status & UNIPOLAR))
1002                 devpriv->ai_unipolar = 1;
1003         else
1004                 devpriv->ai_unipolar = 0;
1005
1006
1007         if ((status & DAS16_MUXBIT))
1008                 devpriv->ai_singleended = 1;
1009         else
1010                 devpriv->ai_singleended = 0;
1011
1012
1013         /* diobits indicates boards */
1014
1015         diobits = inb(dev->iobase + DAS16_DIO) & 0xf0;
1016
1017         printk(KERN_INFO " id bits are 0x%02x\n", diobits);
1018         if (board->id != diobits) {
1019                 printk(KERN_INFO " requested board's id bits are 0x%x (ignore)\n",
1020                        board->id);
1021         }
1022
1023         return 0;
1024 }
1025
1026 static int das1600_mode_detect(struct comedi_device *dev)
1027 {
1028         struct das16_private_struct *devpriv = dev->private;
1029         int status = 0;
1030
1031         status = inb(dev->iobase + DAS1600_STATUS_B);
1032
1033         if (status & DAS1600_CLK_10MHZ) {
1034                 devpriv->clockbase = 100;
1035                 printk(KERN_INFO " 10MHz pacer clock\n");
1036         } else {
1037                 devpriv->clockbase = 1000;
1038                 printk(KERN_INFO " 1MHz pacer clock\n");
1039         }
1040
1041         reg_dump(dev);
1042
1043         return 0;
1044 }
1045
1046 static void das16_ai_munge(struct comedi_device *dev,
1047                            struct comedi_subdevice *s, void *array,
1048                            unsigned int num_bytes,
1049                            unsigned int start_chan_index)
1050 {
1051         const struct das16_board *board = comedi_board(dev);
1052         unsigned int i, num_samples = num_bytes / sizeof(short);
1053         short *data = array;
1054
1055         for (i = 0; i < num_samples; i++) {
1056                 data[i] = le16_to_cpu(data[i]);
1057                 if (board->ai_nbits == 12)
1058                         data[i] = (data[i] >> 4) & 0xfff;
1059
1060         }
1061 }
1062
1063 /*
1064  *
1065  * Options list:
1066  *   0  I/O base
1067  *   1  IRQ
1068  *   2  DMA
1069  *   3  Clock speed (in MHz)
1070  */
1071 static int das16_attach(struct comedi_device *dev, struct comedi_devconfig *it)
1072 {
1073         const struct das16_board *board = comedi_board(dev);
1074         struct das16_private_struct *devpriv;
1075         struct comedi_subdevice *s;
1076         int ret;
1077         unsigned int irq;
1078         unsigned int dma_chan;
1079         int timer_mode;
1080         unsigned long flags;
1081         struct comedi_krange *user_ai_range, *user_ao_range;
1082
1083 #if 0
1084         irq = it->options[1];
1085         timer_mode = it->options[8];
1086 #endif
1087         /* always use time_mode since using irq can drop samples while
1088          * waiting for dma done interrupt (due to hardware limitations) */
1089         irq = 0;
1090         timer_mode = 1;
1091         if (timer_mode)
1092                 irq = 0;
1093
1094         /*  check that clock setting is valid */
1095         if (it->options[3]) {
1096                 if (it->options[3] != 0 &&
1097                     it->options[3] != 1 && it->options[3] != 10) {
1098                         printk
1099                             ("\n Invalid option.  Master clock must be set "
1100                                                         "to 1 or 10 (MHz)\n");
1101                         return -EINVAL;
1102                 }
1103         }
1104
1105         devpriv = kzalloc(sizeof(*devpriv), GFP_KERNEL);
1106         if (!devpriv)
1107                 return -ENOMEM;
1108         dev->private = devpriv;
1109
1110         if (board->size < 0x400) {
1111                 ret = comedi_request_region(dev, it->options[0], board->size);
1112                 if (ret)
1113                         return ret;
1114         } else {
1115                 ret = comedi_request_region(dev, it->options[0], 0x10);
1116                 if (ret)
1117                         return ret;
1118                 /* Request an additional region for the 8255 */
1119                 ret = __comedi_request_region(dev, dev->iobase + 0x400,
1120                                               board->size & 0x3ff);
1121                 if (ret)
1122                         return ret;
1123                 devpriv->extra_iobase = dev->iobase + 0x400;
1124         }
1125
1126         /*  probe id bits to make sure they are consistent */
1127         if (das16_probe(dev, it)) {
1128                 printk(KERN_ERR " id bits do not match selected board, aborting\n");
1129                 return -EINVAL;
1130         }
1131
1132         /*  get master clock speed */
1133         if (board->size < 0x400) {
1134                 if (it->options[3])
1135                         devpriv->clockbase = 1000 / it->options[3];
1136                 else
1137                         devpriv->clockbase = 1000;      /*  1 MHz default */
1138         } else {
1139                 das1600_mode_detect(dev);
1140         }
1141
1142         /* now for the irq */
1143         if (irq > 1 && irq < 8) {
1144                 ret = request_irq(irq, das16_dma_interrupt, 0,
1145                                   dev->board_name, dev);
1146
1147                 if (ret < 0)
1148                         return ret;
1149                 dev->irq = irq;
1150                 printk(KERN_INFO " ( irq = %u )", irq);
1151         } else if (irq == 0) {
1152                 printk(" ( no irq )");
1153         } else {
1154                 printk(" invalid irq\n");
1155                 return -EINVAL;
1156         }
1157
1158         /*  initialize dma */
1159         dma_chan = it->options[2];
1160         if (dma_chan == 1 || dma_chan == 3) {
1161                 /*  allocate dma buffers */
1162                 int i;
1163                 for (i = 0; i < 2; i++) {
1164                         devpriv->dma_buffer[i] = pci_alloc_consistent(
1165                                                 NULL, DAS16_DMA_SIZE,
1166                                                 &devpriv->dma_buffer_addr[i]);
1167
1168                         if (devpriv->dma_buffer[i] == NULL)
1169                                 return -ENOMEM;
1170                 }
1171                 if (request_dma(dma_chan, dev->board_name)) {
1172                         printk(KERN_ERR " failed to allocate dma channel %i\n",
1173                                dma_chan);
1174                         return -EINVAL;
1175                 }
1176                 devpriv->dma_chan = dma_chan;
1177                 flags = claim_dma_lock();
1178                 disable_dma(devpriv->dma_chan);
1179                 set_dma_mode(devpriv->dma_chan, DMA_MODE_READ);
1180                 release_dma_lock(flags);
1181                 printk(KERN_INFO " ( dma = %u)\n", dma_chan);
1182         } else if (dma_chan == 0) {
1183                 printk(KERN_INFO " ( no dma )\n");
1184         } else {
1185                 printk(KERN_ERR " invalid dma channel\n");
1186                 return -EINVAL;
1187         }
1188
1189         /*  get any user-defined input range */
1190         if (board->ai_pg == das16_pg_none &&
1191             (it->options[4] || it->options[5])) {
1192                 /*  allocate single-range range table */
1193                 devpriv->user_ai_range_table =
1194                     kmalloc(sizeof(struct comedi_lrange) +
1195                             sizeof(struct comedi_krange), GFP_KERNEL);
1196                 /*  initialize ai range */
1197                 devpriv->user_ai_range_table->length = 1;
1198                 user_ai_range = devpriv->user_ai_range_table->range;
1199                 user_ai_range->min = it->options[4];
1200                 user_ai_range->max = it->options[5];
1201                 user_ai_range->flags = UNIT_volt;
1202         }
1203         /*  get any user-defined output range */
1204         if (it->options[6] || it->options[7]) {
1205                 /*  allocate single-range range table */
1206                 devpriv->user_ao_range_table =
1207                     kmalloc(sizeof(struct comedi_lrange) +
1208                             sizeof(struct comedi_krange), GFP_KERNEL);
1209                 /*  initialize ao range */
1210                 devpriv->user_ao_range_table->length = 1;
1211                 user_ao_range = devpriv->user_ao_range_table->range;
1212                 user_ao_range->min = it->options[6];
1213                 user_ao_range->max = it->options[7];
1214                 user_ao_range->flags = UNIT_volt;
1215         }
1216
1217         if (timer_mode) {
1218                 init_timer(&(devpriv->timer));
1219                 devpriv->timer.function = das16_timer_interrupt;
1220                 devpriv->timer.data = (unsigned long)dev;
1221         }
1222         devpriv->timer_mode = timer_mode ? 1 : 0;
1223
1224         ret = comedi_alloc_subdevices(dev, 5);
1225         if (ret)
1226                 return ret;
1227
1228         s = &dev->subdevices[0];
1229         dev->read_subdev = s;
1230         /* ai */
1231         if (board->ai) {
1232                 s->type = COMEDI_SUBD_AI;
1233                 s->subdev_flags = SDF_READABLE | SDF_CMD_READ;
1234                 if (devpriv->ai_singleended) {
1235                         s->n_chan = 16;
1236                         s->len_chanlist = 16;
1237                         s->subdev_flags |= SDF_GROUND;
1238                 } else {
1239                         s->n_chan = 8;
1240                         s->len_chanlist = 8;
1241                         s->subdev_flags |= SDF_DIFF;
1242                 }
1243                 s->maxdata = (1 << board->ai_nbits) - 1;
1244                 if (devpriv->user_ai_range_table) { /*  user defined ai range */
1245                         s->range_table = devpriv->user_ai_range_table;
1246                 } else if (devpriv->ai_unipolar) {
1247                         s->range_table = das16_ai_uni_lranges[board->ai_pg];
1248                 } else {
1249                         s->range_table = das16_ai_bip_lranges[board->ai_pg];
1250                 }
1251                 s->insn_read = board->ai;
1252                 s->do_cmdtest = das16_cmd_test;
1253                 s->do_cmd = das16_cmd_exec;
1254                 s->cancel = das16_cancel;
1255                 s->munge = das16_ai_munge;
1256         } else {
1257                 s->type = COMEDI_SUBD_UNUSED;
1258         }
1259
1260         s = &dev->subdevices[1];
1261         /* ao */
1262         if (board->ao) {
1263                 s->type = COMEDI_SUBD_AO;
1264                 s->subdev_flags = SDF_WRITABLE;
1265                 s->n_chan = 2;
1266                 s->maxdata = (1 << board->ao_nbits) - 1;
1267                 /*  user defined ao range */
1268                 if (devpriv->user_ao_range_table)
1269                         s->range_table = devpriv->user_ao_range_table;
1270                 else
1271                         s->range_table = &range_unknown;
1272
1273                 s->insn_write = board->ao;
1274         } else {
1275                 s->type = COMEDI_SUBD_UNUSED;
1276         }
1277
1278         s = &dev->subdevices[2];
1279         /* di */
1280         if (board->di) {
1281                 s->type = COMEDI_SUBD_DI;
1282                 s->subdev_flags = SDF_READABLE;
1283                 s->n_chan = 4;
1284                 s->maxdata = 1;
1285                 s->range_table = &range_digital;
1286                 s->insn_bits = board->di;
1287         } else {
1288                 s->type = COMEDI_SUBD_UNUSED;
1289         }
1290
1291         s = &dev->subdevices[3];
1292         /* do */
1293         if (board->do_) {
1294                 s->type = COMEDI_SUBD_DO;
1295                 s->subdev_flags = SDF_WRITABLE | SDF_READABLE;
1296                 s->n_chan = 4;
1297                 s->maxdata = 1;
1298                 s->range_table = &range_digital;
1299                 s->insn_bits = board->do_;
1300                 /*  initialize digital output lines */
1301                 outb(s->state, dev->iobase + DAS16_DIO);
1302         } else {
1303                 s->type = COMEDI_SUBD_UNUSED;
1304         }
1305
1306         s = &dev->subdevices[4];
1307         /* 8255 */
1308         if (board->i8255_offset != 0) {
1309                 subdev_8255_init(dev, s, NULL, (dev->iobase +
1310                                                 board->i8255_offset));
1311         } else {
1312                 s->type = COMEDI_SUBD_UNUSED;
1313         }
1314
1315         das16_reset(dev);
1316         /* set the interrupt level */
1317         devpriv->control_state = DAS16_IRQ(dev->irq);
1318         outb(devpriv->control_state, dev->iobase + DAS16_CONTROL);
1319
1320         /*  turn on das1600 mode if available */
1321         if (board->size > 0x400) {
1322                 outb(DAS1600_ENABLE_VAL, dev->iobase + DAS1600_ENABLE);
1323                 outb(0, dev->iobase + DAS1600_CONV);
1324                 outb(0, dev->iobase + DAS1600_BURST);
1325         }
1326
1327         return 0;
1328 }
1329
1330 static void das16_detach(struct comedi_device *dev)
1331 {
1332         const struct das16_board *board = comedi_board(dev);
1333         struct das16_private_struct *devpriv = dev->private;
1334
1335         das16_reset(dev);
1336         if (devpriv) {
1337                 int i;
1338                 for (i = 0; i < 2; i++) {
1339                         if (devpriv->dma_buffer[i])
1340                                 pci_free_consistent(NULL, DAS16_DMA_SIZE,
1341                                                     devpriv->dma_buffer[i],
1342                                                     devpriv->
1343                                                     dma_buffer_addr[i]);
1344                 }
1345                 if (devpriv->dma_chan)
1346                         free_dma(devpriv->dma_chan);
1347                 kfree(devpriv->user_ai_range_table);
1348                 kfree(devpriv->user_ao_range_table);
1349         }
1350         if (devpriv->extra_iobase)
1351                 release_region(devpriv->extra_iobase, board->size & 0x3ff);
1352         comedi_legacy_detach(dev);
1353 }
1354
1355 static const struct das16_board das16_boards[] = {
1356         {
1357                 .name           = "das-16",
1358                 .ai             = das16_ai_rinsn,
1359                 .ai_nbits       = 12,
1360                 .ai_speed       = 15000,
1361                 .ai_pg          = das16_pg_none,
1362                 .ao             = das16_ao_winsn,
1363                 .ao_nbits       = 12,
1364                 .di             = das16_di_rbits,
1365                 .do_            = das16_do_wbits,
1366                 .i8255_offset   = 0x10,
1367                 .i8254_offset   = 0x0c,
1368                 .size           = 0x14,
1369                 .id             = 0x00,
1370         }, {
1371                 .name           = "das-16g",
1372                 .ai             = das16_ai_rinsn,
1373                 .ai_nbits       = 12,
1374                 .ai_speed       = 15000,
1375                 .ai_pg          = das16_pg_none,
1376                 .ao             = das16_ao_winsn,
1377                 .ao_nbits       = 12,
1378                 .di             = das16_di_rbits,
1379                 .do_            = das16_do_wbits,
1380                 .i8255_offset   = 0x10,
1381                 .i8254_offset   = 0x0c,
1382                 .size           = 0x14,
1383                 .id             = 0x00,
1384         }, {
1385                 .name           = "das-16f",
1386                 .ai             = das16_ai_rinsn,
1387                 .ai_nbits       = 12,
1388                 .ai_speed       = 8500,
1389                 .ai_pg          = das16_pg_none,
1390                 .ao             = das16_ao_winsn,
1391                 .ao_nbits       = 12,
1392                 .di             = das16_di_rbits,
1393                 .do_            = das16_do_wbits,
1394                 .i8255_offset   = 0x10,
1395                 .i8254_offset   = 0x0c,
1396                 .size           = 0x14,
1397                 .id             = 0x00,
1398         }, {
1399                 .name           = "cio-das16",
1400                 .ai             = das16_ai_rinsn,
1401                 .ai_nbits       = 12,
1402                 .ai_speed       = 20000,
1403                 .ai_pg          = das16_pg_none,
1404                 .ao             = das16_ao_winsn,
1405                 .ao_nbits       = 12,
1406                 .di             = das16_di_rbits,
1407                 .do_            = das16_do_wbits,
1408                 .i8255_offset   = 0x10,
1409                 .i8254_offset   = 0x0c,
1410                 .size           = 0x14,
1411                 .id             = 0x80,
1412         }, {
1413                 .name           = "cio-das16/f",
1414                 .ai             = das16_ai_rinsn,
1415                 .ai_nbits       = 12,
1416                 .ai_speed       = 10000,
1417                 .ai_pg          = das16_pg_none,
1418                 .ao             = das16_ao_winsn,
1419                 .ao_nbits       = 12,
1420                 .di             = das16_di_rbits,
1421                 .do_            = das16_do_wbits,
1422                 .i8255_offset   = 0x10,
1423                 .i8254_offset   = 0x0c,
1424                 .size           = 0x14,
1425                 .id             = 0x80,
1426         }, {
1427                 .name           = "cio-das16/jr",
1428                 .ai             = das16_ai_rinsn,
1429                 .ai_nbits       = 12,
1430                 .ai_speed       = 7692,
1431                 .ai_pg          = das16_pg_16jr,
1432                 .ao             = NULL,
1433                 .di             = das16_di_rbits,
1434                 .do_            = das16_do_wbits,
1435                 .i8255_offset   = 0,
1436                 .i8254_offset   = 0x0c,
1437                 .size           = 0x10,
1438                 .id             = 0x00,
1439         }, {
1440                 .name           = "pc104-das16jr",
1441                 .ai             = das16_ai_rinsn,
1442                 .ai_nbits       = 12,
1443                 .ai_speed       = 3300,
1444                 .ai_pg          = das16_pg_16jr,
1445                 .ao             = NULL,
1446                 .di             = das16_di_rbits,
1447                 .do_            = das16_do_wbits,
1448                 .i8255_offset   = 0,
1449                 .i8254_offset   = 0x0c,
1450                 .size           = 0x10,
1451                 .id             = 0x00,
1452         }, {
1453                 .name           = "cio-das16jr/16",
1454                 .ai             = das16_ai_rinsn,
1455                 .ai_nbits       = 16,
1456                 .ai_speed       = 10000,
1457                 .ai_pg          = das16_pg_16jr_16,
1458                 .ao             = NULL,
1459                 .di             = das16_di_rbits,
1460                 .do_            = das16_do_wbits,
1461                 .i8255_offset   = 0,
1462                 .i8254_offset   = 0x0c,
1463                 .size           = 0x10,
1464                 .id             = 0x00,
1465         }, {
1466                 .name           = "pc104-das16jr/16",
1467                 .ai             = das16_ai_rinsn,
1468                 .ai_nbits       = 16,
1469                 .ai_speed       = 10000,
1470                 .ai_pg          = das16_pg_16jr_16,
1471                 .ao             = NULL,
1472                 .di             = das16_di_rbits,
1473                 .do_            = das16_do_wbits,
1474                 .i8255_offset   = 0,
1475                 .i8254_offset   = 0x0c,
1476                 .size           = 0x10,
1477                 .id             = 0x00,
1478         }, {
1479                 .name           = "das-1201",
1480                 .ai             = das16_ai_rinsn,
1481                 .ai_nbits       = 12,
1482                 .ai_speed       = 20000,
1483                 .ai_pg          = das16_pg_none,
1484                 .ao             = NULL,
1485                 .di             = das16_di_rbits,
1486                 .do_            = das16_do_wbits,
1487                 .i8255_offset   = 0x400,
1488                 .i8254_offset   = 0x0c,
1489                 .size           = 0x408,
1490                 .id             = 0x20,
1491         }, {
1492                 .name           = "das-1202",
1493                 .ai             = das16_ai_rinsn,
1494                 .ai_nbits       = 12,
1495                 .ai_speed       = 10000,
1496                 .ai_pg          = das16_pg_none,
1497                 .ao             = NULL,
1498                 .di             = das16_di_rbits,
1499                 .do_            = das16_do_wbits,
1500                 .i8255_offset   = 0x400,
1501                 .i8254_offset   = 0x0c,
1502                 .size           = 0x408,
1503                 .id             = 0x20,
1504         }, {
1505                 .name           = "das-1401",
1506                 .ai             = das16_ai_rinsn,
1507                 .ai_nbits       = 12,
1508                 .ai_speed       = 10000,
1509                 .ai_pg          = das16_pg_1601,
1510                 .ao             = NULL,
1511                 .di             = das16_di_rbits,
1512                 .do_            = das16_do_wbits,
1513                 .i8255_offset   = 0x0,
1514                 .i8254_offset   = 0x0c,
1515                 .size           = 0x408,
1516                 .id             = 0xc0,
1517         }, {
1518                 .name           = "das-1402",
1519                 .ai             = das16_ai_rinsn,
1520                 .ai_nbits       = 12,
1521                 .ai_speed       = 10000,
1522                 .ai_pg          = das16_pg_1602,
1523                 .ao             = NULL,
1524                 .di             = das16_di_rbits,
1525                 .do_            = das16_do_wbits,
1526                 .i8255_offset   = 0x0,
1527                 .i8254_offset   = 0x0c,
1528                 .size           = 0x408,
1529                 .id             = 0xc0,
1530         }, {
1531                 .name           = "das-1601",
1532                 .ai             = das16_ai_rinsn,
1533                 .ai_nbits       = 12,
1534                 .ai_speed       = 10000,
1535                 .ai_pg          = das16_pg_1601,
1536                 .ao             = das16_ao_winsn,
1537                 .ao_nbits       = 12,
1538                 .di             = das16_di_rbits,
1539                 .do_            = das16_do_wbits,
1540                 .i8255_offset   = 0x400,
1541                 .i8254_offset   = 0x0c,
1542                 .size           = 0x408,
1543                 .id             = 0xc0,
1544         }, {
1545                 .name           = "das-1602",
1546                 .ai             = das16_ai_rinsn,
1547                 .ai_nbits       = 12,
1548                 .ai_speed       = 10000,
1549                 .ai_pg          = das16_pg_1602,
1550                 .ao             = das16_ao_winsn,
1551                 .ao_nbits       = 12,
1552                 .di             = das16_di_rbits,
1553                 .do_            = das16_do_wbits,
1554                 .i8255_offset   = 0x400,
1555                 .i8254_offset   = 0x0c,
1556                 .size           = 0x408,
1557                 .id             = 0xc0,
1558         }, {
1559                 .name           = "cio-das1401/12",
1560                 .ai             = das16_ai_rinsn,
1561                 .ai_nbits       = 12,
1562                 .ai_speed       = 6250,
1563                 .ai_pg          = das16_pg_1601,
1564                 .ao             = NULL,
1565                 .di             = das16_di_rbits,
1566                 .do_            = das16_do_wbits,
1567                 .i8255_offset   = 0,
1568                 .i8254_offset   = 0x0c,
1569                 .size           = 0x408,
1570                 .id             = 0xc0,
1571         }, {
1572                 .name           = "cio-das1402/12",
1573                 .ai             = das16_ai_rinsn,
1574                 .ai_nbits       = 12,
1575                 .ai_speed       = 6250,
1576                 .ai_pg          = das16_pg_1602,
1577                 .ao             = NULL,
1578                 .di             = das16_di_rbits,
1579                 .do_            = das16_do_wbits,
1580                 .i8255_offset   = 0,
1581                 .i8254_offset   = 0x0c,
1582                 .size           = 0x408,
1583                 .id             = 0xc0,
1584         }, {
1585                 .name           = "cio-das1402/16",
1586                 .ai             = das16_ai_rinsn,
1587                 .ai_nbits       = 16,
1588                 .ai_speed       = 10000,
1589                 .ai_pg          = das16_pg_1602,
1590                 .ao             = NULL,
1591                 .di             = das16_di_rbits,
1592                 .do_            = das16_do_wbits,
1593                 .i8255_offset   = 0,
1594                 .i8254_offset   = 0x0c,
1595                 .size           = 0x408,
1596                 .id             = 0xc0,
1597         }, {
1598                 .name           = "cio-das1601/12",
1599                 .ai             = das16_ai_rinsn,
1600                 .ai_nbits       = 12,
1601                 .ai_speed       = 6250,
1602                 .ai_pg          = das16_pg_1601,
1603                 .ao             = das16_ao_winsn,
1604                 .ao_nbits       = 12,
1605                 .di             = das16_di_rbits,
1606                 .do_            = das16_do_wbits,
1607                 .i8255_offset   = 0x400,
1608                 .i8254_offset   = 0x0c,
1609                 .size           = 0x408,
1610                 .id             = 0xc0,
1611         }, {
1612                 .name           = "cio-das1602/12",
1613                 .ai             = das16_ai_rinsn,
1614                 .ai_nbits       = 12,
1615                 .ai_speed       = 10000,
1616                 .ai_pg          = das16_pg_1602,
1617                 .ao             = das16_ao_winsn,
1618                 .ao_nbits       = 12,
1619                 .di             = das16_di_rbits,
1620                 .do_            = das16_do_wbits,
1621                 .i8255_offset   = 0x400,
1622                 .i8254_offset   = 0x0c,
1623                 .size           = 0x408,
1624                 .id             = 0xc0,
1625         }, {
1626                 .name           = "cio-das1602/16",
1627                 .ai             = das16_ai_rinsn,
1628                 .ai_nbits       = 16,
1629                 .ai_speed       = 10000,
1630                 .ai_pg          = das16_pg_1602,
1631                 .ao             = das16_ao_winsn,
1632                 .ao_nbits       = 12,
1633                 .di             = das16_di_rbits,
1634                 .do_            = das16_do_wbits,
1635                 .i8255_offset   = 0x400,
1636                 .i8254_offset   = 0x0c,
1637                 .size           = 0x408,
1638                 .id             = 0xc0,
1639         }, {
1640                 .name           = "cio-das16/330",
1641                 .ai             = das16_ai_rinsn,
1642                 .ai_nbits       = 12,
1643                 .ai_speed       = 3030,
1644                 .ai_pg          = das16_pg_16jr,
1645                 .ao             = NULL,
1646                 .di             = das16_di_rbits,
1647                 .do_            = das16_do_wbits,
1648                 .i8255_offset   = 0,
1649                 .i8254_offset   = 0x0c,
1650                 .size           = 0x14,
1651                 .id             = 0xf0,
1652         },
1653 };
1654
1655 static struct comedi_driver das16_driver = {
1656         .driver_name    = "das16",
1657         .module         = THIS_MODULE,
1658         .attach         = das16_attach,
1659         .detach         = das16_detach,
1660         .board_name     = &das16_boards[0].name,
1661         .num_names      = ARRAY_SIZE(das16_boards),
1662         .offset         = sizeof(das16_boards[0]),
1663 };
1664 module_comedi_driver(das16_driver);
1665
1666 MODULE_AUTHOR("Comedi http://www.comedi.org");
1667 MODULE_DESCRIPTION("Comedi low-level driver");
1668 MODULE_LICENSE("GPL");