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