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