drivers/staging/comedi/drivers/das16.c

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