drivers/staging/comedi/drivers/dt282x.c

   1 /*
   2  * dt282x.c
   3  * Comedi driver for Data Translation DT2821 series
   4  *
   5  * COMEDI - Linux Control and Measurement Device Interface
   6  * Copyright (C) 1997-8 David A. Schleef <ds@schleef.org>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  */
  18
  19 /*
  20  * Driver: dt282x
  21  * Description: Data Translation DT2821 series (including DT-EZ)
  22  * Author: ds
  23  * Devices: [Data Translation] DT2821 (dt2821), DT2821-F-16SE (dt2821-f),
  24  *   DT2821-F-8DI (dt2821-f), DT2821-G-16SE (dt2821-g),
  25  *   DT2821-G-8DI (dt2821-g), DT2823 (dt2823), DT2824-PGH (dt2824-pgh),
  26  *   DT2824-PGL (dt2824-pgl), DT2825 (dt2825), DT2827 (dt2827),
  27  *   DT2828 (dt2828), DT2928 (dt2829), DT21-EZ (dt21-ez), DT23-EZ (dt23-ez),
  28  *   DT24-EZ (dt24-ez), DT24-EZ-PGL (dt24-ez-pgl)
  29  * Status: complete
  30  * Updated: Wed, 22 Aug 2001 17:11:34 -0700
  31  *
  32  * Configuration options:
  33  *   [0] - I/O port base address
  34  *   [1] - IRQ (optional, required for async command support)
  35  *   [2] - DMA 1 (optional, required for async command support)
  36  *   [3] - DMA 2 (optional, required for async command support)
  37  *   [4] - AI jumpered for 0=single ended, 1=differential
  38  *   [5] - AI jumpered for 0=straight binary, 1=2's complement
  39  *   [6] - AO 0 data format (deprecated, see below)
  40  *   [7] - AO 1 data format (deprecated, see below)
  41  *   [8] - AI jumpered for 0=[-10,10]V, 1=[0,10], 2=[-5,5], 3=[0,5]
  42  *   [9] - AO channel 0 range (deprecated, see below)
  43  *   [10]- AO channel 1 range (deprecated, see below)
  44  *
  45  * Notes:
  46  *   - AO commands might be broken.
  47  *   - If you try to run a command on both the AI and AO subdevices
  48  *     simultaneously, bad things will happen.  The driver needs to
  49  *     be fixed to check for this situation and return an error.
  50  *   - AO range is not programmable. The AO subdevice has a range_table
  51  *     containing all the possible analog output ranges. Use the range
  52  *     that matches your board configuration to convert between data
  53  *     values and physical units. The format of the data written to the
  54  *     board is handled automatically based on the unipolar/bipolar
  55  *     range that is selected.
  56  */
  57
  58 #include <linux/module.h>
  59 #include "../comedidev.h"
  60
  61 #include <linux/delay.h>
  62 #include <linux/gfp.h>
  63 #include <linux/interrupt.h>
  64 #include <linux/io.h>
  65
  66 #include <asm/dma.h>
  67
  68 #include "comedi_fc.h"
  69
  70 /*
  71  * Register map
  72  */
  73 #define DT2821_ADCSR_REG                0x00
  74 #define DT2821_ADCSR_ADERR              (1 << 15)
  75 #define DT2821_ADCSR_ADCLK              (1 << 9)
  76 #define DT2821_ADCSR_MUXBUSY            (1 << 8)
  77 #define DT2821_ADCSR_ADDONE             (1 << 7)
  78 #define DT2821_ADCSR_IADDONE            (1 << 6)
  79 #define DT2821_ADCSR_GS(x)              (((x) & 0x3) << 4)
  80 #define DT2821_ADCSR_CHAN(x)            (((x) & 0xf) << 0)
  81 #define DT2821_CHANCSR_REG              0x02
  82 #define DT2821_CHANCSR_LLE              (1 << 15)
  83 #define DT2821_CHANCSR_PRESLA(x)        (((x) & 0xf) >> 8)
  84 #define DT2821_CHANCSR_NUMB(x)          ((((x) - 1) & 0xf) << 0)
  85 #define DT2821_ADDAT_REG                0x04
  86 #define DT2821_DACSR_REG                0x06
  87 #define DT2821_DACSR_DAERR              (1 << 15)
  88 #define DT2821_DACSR_YSEL(x)            ((x) << 9)
  89 #define DT2821_DACSR_SSEL               (1 << 8)
  90 #define DT2821_DACSR_DACRDY             (1 << 7)
  91 #define DT2821_DACSR_IDARDY             (1 << 6)
  92 #define DT2821_DACSR_DACLK              (1 << 5)
  93 #define DT2821_DACSR_HBOE               (1 << 1)
  94 #define DT2821_DACSR_LBOE               (1 << 0)
  95 #define DT2821_DADAT_REG                0x08
  96 #define DT2821_DIODAT_REG               0x0a
  97 #define DT2821_SUPCSR_REG               0x0c
  98 #define DT2821_SUPCSR_DMAD              (1 << 15)
  99 #define DT2821_SUPCSR_ERRINTEN          (1 << 14)
 100 #define DT2821_SUPCSR_CLRDMADNE         (1 << 13)
 101 #define DT2821_SUPCSR_DDMA              (1 << 12)
 102 #define DT2821_SUPCSR_DS_PIO            (0 << 10)
 103 #define DT2821_SUPCSR_DS_AD_CLK         (1 << 10)
 104 #define DT2821_SUPCSR_DS_DA_CLK         (2 << 10)
 105 #define DT2821_SUPCSR_DS_AD_TRIG        (3 << 10)
 106 #define DT2821_SUPCSR_BUFFB             (1 << 9)
 107 #define DT2821_SUPCSR_SCDN              (1 << 8)
 108 #define DT2821_SUPCSR_DACON             (1 << 7)
 109 #define DT2821_SUPCSR_ADCINIT           (1 << 6)
 110 #define DT2821_SUPCSR_DACINIT           (1 << 5)
 111 #define DT2821_SUPCSR_PRLD              (1 << 4)
 112 #define DT2821_SUPCSR_STRIG             (1 << 3)
 113 #define DT2821_SUPCSR_XTRIG             (1 << 2)
 114 #define DT2821_SUPCSR_XCLK              (1 << 1)
 115 #define DT2821_SUPCSR_BDINIT            (1 << 0)
 116 #define DT2821_TMRCTR_REG               0x0e
 117
 118 static const struct comedi_lrange range_dt282x_ai_lo_bipolar = {
 119         4, {
 120                 BIP_RANGE(10),
 121                 BIP_RANGE(5),
 122                 BIP_RANGE(2.5),
 123                 BIP_RANGE(1.25)
 124         }
 125 };
 126
 127 static const struct comedi_lrange range_dt282x_ai_lo_unipolar = {
 128         4, {
 129                 UNI_RANGE(10),
 130                 UNI_RANGE(5),
 131                 UNI_RANGE(2.5),
 132                 UNI_RANGE(1.25)
 133         }
 134 };
 135
 136 static const struct comedi_lrange range_dt282x_ai_5_bipolar = {
 137         4, {
 138                 BIP_RANGE(5),
 139                 BIP_RANGE(2.5),
 140                 BIP_RANGE(1.25),
 141                 BIP_RANGE(0.625)
 142         }
 143 };
 144
 145 static const struct comedi_lrange range_dt282x_ai_5_unipolar = {
 146         4, {
 147                 UNI_RANGE(5),
 148                 UNI_RANGE(2.5),
 149                 UNI_RANGE(1.25),
 150                 UNI_RANGE(0.625)
 151         }
 152 };
 153
 154 static const struct comedi_lrange range_dt282x_ai_hi_bipolar = {
 155         4, {
 156                 BIP_RANGE(10),
 157                 BIP_RANGE(1),
 158                 BIP_RANGE(0.1),
 159                 BIP_RANGE(0.02)
 160         }
 161 };
 162
 163 static const struct comedi_lrange range_dt282x_ai_hi_unipolar = {
 164         4, {
 165                 UNI_RANGE(10),
 166                 UNI_RANGE(1),
 167                 UNI_RANGE(0.1),
 168                 UNI_RANGE(0.02)
 169         }
 170 };
 171
 172 /*
 173  * The Analog Output range is set per-channel using jumpers on the board.
 174  * All of these ranges may not be available on some DT2821 series boards.
 175  * The default jumper setting has both channels set for +/-10V output.
 176  */
 177 static const struct comedi_lrange dt282x_ao_range = {
 178         5, {
 179                 BIP_RANGE(10),
 180                 BIP_RANGE(5),
 181                 BIP_RANGE(2.5),
 182                 UNI_RANGE(10),
 183                 UNI_RANGE(5),
 184         }
 185 };
 186
 187 struct dt282x_board {
 188         const char *name;
 189         unsigned int ai_maxdata;
 190         int adchan_se;
 191         int adchan_di;
 192         int ai_speed;
 193         int ispgl;
 194         int dachan;
 195         unsigned int ao_maxdata;
 196 };
 197
 198 static const struct dt282x_board boardtypes[] = {
 199         {
 200                 .name           = "dt2821",
 201                 .ai_maxdata     = 0x0fff,
 202                 .adchan_se      = 16,
 203                 .adchan_di      = 8,
 204                 .ai_speed       = 20000,
 205                 .dachan         = 2,
 206                 .ao_maxdata     = 0x0fff,
 207         }, {
 208                 .name           = "dt2821-f",
 209                 .ai_maxdata     = 0x0fff,
 210                 .adchan_se      = 16,
 211                 .adchan_di      = 8,
 212                 .ai_speed       = 6500,
 213                 .dachan         = 2,
 214                 .ao_maxdata     = 0x0fff,
 215         }, {
 216                 .name           = "dt2821-g",
 217                 .ai_maxdata     = 0x0fff,
 218                 .adchan_se      = 16,
 219                 .adchan_di      = 8,
 220                 .ai_speed       = 4000,
 221                 .dachan         = 2,
 222                 .ao_maxdata     = 0x0fff,
 223         }, {
 224                 .name           = "dt2823",
 225                 .ai_maxdata     = 0xffff,
 226                 .adchan_di      = 4,
 227                 .ai_speed       = 10000,
 228                 .dachan         = 2,
 229                 .ao_maxdata     = 0xffff,
 230         }, {
 231                 .name           = "dt2824-pgh",
 232                 .ai_maxdata     = 0x0fff,
 233                 .adchan_se      = 16,
 234                 .adchan_di      = 8,
 235                 .ai_speed       = 20000,
 236         }, {
 237                 .name           = "dt2824-pgl",
 238                 .ai_maxdata     = 0x0fff,
 239                 .adchan_se      = 16,
 240                 .adchan_di      = 8,
 241                 .ai_speed       = 20000,
 242                 .ispgl          = 1,
 243         }, {
 244                 .name           = "dt2825",
 245                 .ai_maxdata     = 0x0fff,
 246                 .adchan_se      = 16,
 247                 .adchan_di      = 8,
 248                 .ai_speed       = 20000,
 249                 .ispgl          = 1,
 250                 .dachan         = 2,
 251                 .ao_maxdata     = 0x0fff,
 252         }, {
 253                 .name           = "dt2827",
 254                 .ai_maxdata     = 0xffff,
 255                 .adchan_di      = 4,
 256                 .ai_speed       = 10000,
 257                 .dachan         = 2,
 258                 .ao_maxdata     = 0x0fff,
 259         }, {
 260                 .name           = "dt2828",
 261                 .ai_maxdata     = 0x0fff,
 262                 .adchan_se      = 4,
 263                 .ai_speed       = 10000,
 264                 .dachan         = 2,
 265                 .ao_maxdata     = 0x0fff,
 266         }, {
 267                 .name           = "dt2829",
 268                 .ai_maxdata     = 0xffff,
 269                 .adchan_se      = 8,
 270                 .ai_speed       = 33250,
 271                 .dachan         = 2,
 272                 .ao_maxdata     = 0xffff,
 273         }, {
 274                 .name           = "dt21-ez",
 275                 .ai_maxdata     = 0x0fff,
 276                 .adchan_se      = 16,
 277                 .adchan_di      = 8,
 278                 .ai_speed       = 10000,
 279                 .dachan         = 2,
 280                 .ao_maxdata     = 0x0fff,
 281         }, {
 282                 .name           = "dt23-ez",
 283                 .ai_maxdata     = 0xffff,
 284                 .adchan_se      = 16,
 285                 .adchan_di      = 8,
 286                 .ai_speed       = 10000,
 287         }, {
 288                 .name           = "dt24-ez",
 289                 .ai_maxdata     = 0x0fff,
 290                 .adchan_se      = 16,
 291                 .adchan_di      = 8,
 292                 .ai_speed       = 10000,
 293         }, {
 294                 .name           = "dt24-ez-pgl",
 295                 .ai_maxdata     = 0x0fff,
 296                 .adchan_se      = 16,
 297                 .adchan_di      = 8,
 298                 .ai_speed       = 10000,
 299                 .ispgl          = 1,
 300         },
 301 };
 302
 303 struct dt282x_dma_desc {
 304         unsigned int chan;      /* DMA channel */
 305         void *virt_addr;        /* virtual address of DMA buffer */
 306         dma_addr_t hw_addr;     /* hardware (bus) address of DMA buffer */
 307         unsigned int size;      /* transfer size (in bytes) */
 308         char mode;              /* DMA_MODE_* */
 309 };
 310
 311 struct dt282x_private {
 312         unsigned int ad_2scomp:1;
 313
 314         unsigned int divisor;
 315
 316         int dacsr;      /* software copies of registers */
 317         int adcsr;
 318         int supcsr;
 319
 320         int ntrig;
 321         int nread;
 322
 323         struct dt282x_dma_desc dma_desc[2];
 324         int dma_maxsize;        /* max size of DMA transfer (in bytes) */
 325         int cur_dma;
 326         int dma_dir;
 327 };
 328
 329 static void dt282x_isadma_program(struct dt282x_dma_desc *dma)
 330 {
 331         unsigned long flags;
 332
 333         flags = claim_dma_lock();
 334         clear_dma_ff(dma->chan);
 335         set_dma_mode(dma->chan, dma->mode);
 336         set_dma_addr(dma->chan, dma->hw_addr);
 337         set_dma_count(dma->chan, dma->size);
 338         enable_dma(dma->chan);
 339         release_dma_lock(flags);
 340 }
 341
 342 static void dt282x_isadma_disable(struct dt282x_dma_desc *dma)
 343 {
 344         unsigned long flags;
 345
 346         flags = claim_dma_lock();
 347         disable_dma(dma->chan);
 348         release_dma_lock(flags);
 349 }
 350
 351 static int dt282x_prep_ai_dma(struct comedi_device *dev, int dma_index, int n)
 352 {
 353         struct dt282x_private *devpriv = dev->private;
 354         struct dt282x_dma_desc *dma = &devpriv->dma_desc[dma_index];
 355
 356         if (!devpriv->ntrig)
 357                 return 0;
 358
 359         if (n == 0)
 360                 n = devpriv->dma_maxsize;
 361         if (n > devpriv->ntrig * 2)
 362                 n = devpriv->ntrig * 2;
 363         devpriv->ntrig -= n / 2;
 364
 365         dma->size = n;
 366         dma->mode = DMA_MODE_READ;
 367
 368         dt282x_isadma_program(dma);
 369
 370         return n;
 371 }
 372
 373 static int dt282x_prep_ao_dma(struct comedi_device *dev, int dma_index, int n)
 374 {
 375         struct dt282x_private *devpriv = dev->private;
 376         struct dt282x_dma_desc *dma = &devpriv->dma_desc[dma_index];
 377
 378         dma->size = n;
 379         dma->mode = DMA_MODE_WRITE;
 380
 381         dt282x_isadma_program(dma);
 382
 383         return n;
 384 }
 385
 386 static void dt282x_disable_dma(struct comedi_device *dev)
 387 {
 388         struct dt282x_private *devpriv = dev->private;
 389         int i;
 390
 391         for (i = 0; i < 2; i++)
 392                 dt282x_isadma_disable(&devpriv->dma_desc[i]);
 393 }
 394
 395 static unsigned int dt282x_ns_to_timer(unsigned int *ns, unsigned int flags)
 396 {
 397         unsigned int prescale, base, divider;
 398
 399         for (prescale = 0; prescale < 16; prescale++) {
 400                 if (prescale == 1)
 401                         continue;
 402                 base = 250 * (1 << prescale);
 403                 switch (flags & CMDF_ROUND_MASK) {
 404                 case CMDF_ROUND_NEAREST:
 405                 default:
 406                         divider = (*ns + base / 2) / base;
 407                         break;
 408                 case CMDF_ROUND_DOWN:
 409                         divider = (*ns) / base;
 410                         break;
 411                 case CMDF_ROUND_UP:
 412                         divider = (*ns + base - 1) / base;
 413                         break;
 414                 }
 415                 if (divider < 256) {
 416                         *ns = divider * base;
 417                         return (prescale << 8) | (255 - divider);
 418                 }
 419         }
 420         base = 250 * (1 << 15);
 421         divider = 255;
 422         *ns = divider * base;
 423         return (15 << 8) | (255 - divider);
 424 }
 425
 426 static void dt282x_munge(struct comedi_device *dev,
 427                          struct comedi_subdevice *s,
 428                          unsigned short *buf,
 429                          unsigned int nbytes)
 430 {
 431         struct dt282x_private *devpriv = dev->private;
 432         unsigned int val;
 433         int i;
 434
 435         if (nbytes % 2)
 436                 dev_err(dev->class_dev,
 437                         "bug! odd number of bytes from dma xfer\n");
 438
 439         for (i = 0; i < nbytes / 2; i++) {
 440                 val = buf[i];
 441                 val &= s->maxdata;
 442                 if (devpriv->ad_2scomp)
 443                         val = comedi_offset_munge(s, val);
 444
 445                 buf[i] = val;
 446         }
 447 }
 448
 449 static unsigned int dt282x_ao_setup_dma(struct comedi_device *dev,
 450                                         struct comedi_subdevice *s,
 451                                         int cur_dma)
 452 {
 453         struct dt282x_private *devpriv = dev->private;
 454         struct dt282x_dma_desc *dma = &devpriv->dma_desc[cur_dma];
 455         unsigned int nsamples = comedi_bytes_to_samples(s, devpriv->dma_maxsize);
 456         unsigned int nbytes;
 457
 458         nbytes = comedi_buf_read_samples(s, dma->virt_addr, nsamples);
 459         if (nbytes)
 460                 dt282x_prep_ao_dma(dev, cur_dma, nbytes);
 461         else
 462                 dev_err(dev->class_dev, "AO underrun\n");
 463
 464         return nbytes;
 465 }
 466
 467 static void dt282x_ao_dma_interrupt(struct comedi_device *dev,
 468                                     struct comedi_subdevice *s)
 469 {
 470         struct dt282x_private *devpriv = dev->private;
 471         struct dt282x_dma_desc *dma = &devpriv->dma_desc[devpriv->cur_dma];
 472
 473         outw(devpriv->supcsr | DT2821_SUPCSR_CLRDMADNE,
 474              dev->iobase + DT2821_SUPCSR_REG);
 475
 476         dt282x_isadma_disable(dma);
 477
 478         if (!dt282x_ao_setup_dma(dev, s, devpriv->cur_dma))
 479                 s->async->events |= COMEDI_CB_OVERFLOW;
 480
 481         devpriv->cur_dma = 1 - devpriv->cur_dma;
 482 }
 483
 484 static void dt282x_ai_dma_interrupt(struct comedi_device *dev,
 485                                     struct comedi_subdevice *s)
 486 {
 487         struct dt282x_private *devpriv = dev->private;
 488         struct dt282x_dma_desc *dma = &devpriv->dma_desc[devpriv->cur_dma];
 489         unsigned int nsamples = comedi_bytes_to_samples(s, dma->size);
 490         int ret;
 491
 492         outw(devpriv->supcsr | DT2821_SUPCSR_CLRDMADNE,
 493              dev->iobase + DT2821_SUPCSR_REG);
 494
 495         dt282x_isadma_disable(dma);
 496
 497         dt282x_munge(dev, s, dma->virt_addr, dma->size);
 498         ret = comedi_buf_write_samples(s, dma->virt_addr, nsamples);
 499         if (ret != dma->size)
 500                 return;
 501
 502         devpriv->nread -= nsamples;
 503         if (devpriv->nread < 0) {
 504                 dev_info(dev->class_dev, "nread off by one\n");
 505                 devpriv->nread = 0;
 506         }
 507         if (!devpriv->nread) {
 508                 s->async->events |= COMEDI_CB_EOA;
 509                 return;
 510         }
 511 #if 0
 512         /* clear the dual dma flag, making this the last dma segment */
 513         /* XXX probably wrong */
 514         if (!devpriv->ntrig) {
 515                 devpriv->supcsr &= ~DT2821_SUPCSR_DDMA;
 516                 outw(devpriv->supcsr, dev->iobase + DT2821_SUPCSR_REG);
 517         }
 518 #endif
 519         /* restart the channel */
 520         dt282x_prep_ai_dma(dev, devpriv->cur_dma, 0);
 521
 522         devpriv->cur_dma = 1 - devpriv->cur_dma;
 523 }
 524
 525 static irqreturn_t dt282x_interrupt(int irq, void *d)
 526 {
 527         struct comedi_device *dev = d;
 528         struct dt282x_private *devpriv = dev->private;
 529         struct comedi_subdevice *s = dev->read_subdev;
 530         struct comedi_subdevice *s_ao = dev->write_subdev;
 531         unsigned int supcsr, adcsr, dacsr;
 532         int handled = 0;
 533
 534         if (!dev->attached) {
 535                 dev_err(dev->class_dev, "spurious interrupt\n");
 536                 return IRQ_HANDLED;
 537         }
 538
 539         adcsr = inw(dev->iobase + DT2821_ADCSR_REG);
 540         dacsr = inw(dev->iobase + DT2821_DACSR_REG);
 541         supcsr = inw(dev->iobase + DT2821_SUPCSR_REG);
 542         if (supcsr & DT2821_SUPCSR_DMAD) {
 543                 if (devpriv->dma_dir == DMA_MODE_READ)
 544                         dt282x_ai_dma_interrupt(dev, s);
 545                 else
 546                         dt282x_ao_dma_interrupt(dev, s_ao);
 547                 handled = 1;
 548         }
 549         if (adcsr & DT2821_ADCSR_ADERR) {
 550                 if (devpriv->nread != 0) {
 551                         dev_err(dev->class_dev, "A/D error\n");
 552                         s->async->events |= COMEDI_CB_ERROR;
 553                 }
 554                 handled = 1;
 555         }
 556         if (dacsr & DT2821_DACSR_DAERR) {
 557                 dev_err(dev->class_dev, "D/A error\n");
 558                 s_ao->async->events |= COMEDI_CB_ERROR;
 559                 handled = 1;
 560         }
 561 #if 0
 562         if (adcsr & DT2821_ADCSR_ADDONE) {
 563                 unsigned short data;
 564
 565                 data = inw(dev->iobase + DT2821_ADDAT_REG);
 566                 data &= s->maxdata;
 567                 if (devpriv->ad_2scomp)
 568                         data = comedi_offset_munge(s, data);
 569
 570                 comedi_buf_write_samples(s, &data, 1);
 571
 572                 devpriv->nread--;
 573                 if (!devpriv->nread) {
 574                         s->async->events |= COMEDI_CB_EOA;
 575                 } else {
 576                         if (supcsr & DT2821_SUPCSR_SCDN)
 577                                 outw(devpriv->supcsr | DT2821_SUPCSR_STRIG,
 578                                      dev->iobase + DT2821_SUPCSR_REG);
 579                 }
 580                 handled = 1;
 581         }
 582 #endif
 583         comedi_handle_events(dev, s);
 584         comedi_handle_events(dev, s_ao);
 585
 586         return IRQ_RETVAL(handled);
 587 }
 588
 589 static void dt282x_load_changain(struct comedi_device *dev, int n,
 590                                  unsigned int *chanlist)
 591 {
 592         struct dt282x_private *devpriv = dev->private;
 593         int i;
 594
 595         outw(DT2821_CHANCSR_LLE | DT2821_CHANCSR_NUMB(n),
 596              dev->iobase + DT2821_CHANCSR_REG);
 597         for (i = 0; i < n; i++) {
 598                 unsigned int chan = CR_CHAN(chanlist[i]);
 599                 unsigned int range = CR_RANGE(chanlist[i]);
 600
 601                 outw(devpriv->adcsr |
 602                      DT2821_ADCSR_GS(range) |
 603                      DT2821_ADCSR_CHAN(chan),
 604                      dev->iobase + DT2821_ADCSR_REG);
 605         }
 606         outw(DT2821_CHANCSR_NUMB(n), dev->iobase + DT2821_CHANCSR_REG);
 607 }
 608
 609 static int dt282x_ai_timeout(struct comedi_device *dev,
 610                              struct comedi_subdevice *s,
 611                              struct comedi_insn *insn,
 612                              unsigned long context)
 613 {
 614         unsigned int status;
 615
 616         status = inw(dev->iobase + DT2821_ADCSR_REG);
 617         switch (context) {
 618         case DT2821_ADCSR_MUXBUSY:
 619                 if ((status & DT2821_ADCSR_MUXBUSY) == 0)
 620                         return 0;
 621                 break;
 622         case DT2821_ADCSR_ADDONE:
 623                 if (status & DT2821_ADCSR_ADDONE)
 624                         return 0;
 625                 break;
 626         default:
 627                 return -EINVAL;
 628         }
 629         return -EBUSY;
 630 }
 631
 632 /*
 633  *    Performs a single A/D conversion.
 634  *      - Put channel/gain into channel-gain list
 635  *      - preload multiplexer
 636  *      - trigger conversion and wait for it to finish
 637  */
 638 static int dt282x_ai_insn_read(struct comedi_device *dev,
 639                                struct comedi_subdevice *s,
 640                                struct comedi_insn *insn,
 641                                unsigned int *data)
 642 {
 643         struct dt282x_private *devpriv = dev->private;
 644         unsigned int val;
 645         int ret;
 646         int i;
 647
 648         /* XXX should we really be enabling the ad clock here? */
 649         devpriv->adcsr = DT2821_ADCSR_ADCLK;
 650         outw(devpriv->adcsr, dev->iobase + DT2821_ADCSR_REG);
 651
 652         dt282x_load_changain(dev, 1, &insn->chanspec);
 653
 654         outw(devpriv->supcsr | DT2821_SUPCSR_PRLD,
 655              dev->iobase + DT2821_SUPCSR_REG);
 656         ret = comedi_timeout(dev, s, insn,
 657                              dt282x_ai_timeout, DT2821_ADCSR_MUXBUSY);
 658         if (ret)
 659                 return ret;
 660
 661         for (i = 0; i < insn->n; i++) {
 662                 outw(devpriv->supcsr | DT2821_SUPCSR_STRIG,
 663                      dev->iobase + DT2821_SUPCSR_REG);
 664
 665                 ret = comedi_timeout(dev, s, insn,
 666                                      dt282x_ai_timeout, DT2821_ADCSR_ADDONE);
 667                 if (ret)
 668                         return ret;
 669
 670                 val = inw(dev->iobase + DT2821_ADDAT_REG);
 671                 val &= s->maxdata;
 672                 if (devpriv->ad_2scomp)
 673                         val = comedi_offset_munge(s, val);
 674
 675                 data[i] = val;
 676         }
 677
 678         return i;
 679 }
 680
 681 static int dt282x_ai_cmdtest(struct comedi_device *dev,
 682                              struct comedi_subdevice *s,
 683                              struct comedi_cmd *cmd)
 684 {
 685         const struct dt282x_board *board = dev->board_ptr;
 686         struct dt282x_private *devpriv = dev->private;
 687         int err = 0;
 688         unsigned int arg;
 689
 690         /* Step 1 : check if triggers are trivially valid */
 691
 692         err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
 693         err |= cfc_check_trigger_src(&cmd->scan_begin_src,
 694                                         TRIG_FOLLOW | TRIG_EXT);
 695         err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_TIMER);
 696         err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
 697         err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
 698
 699         if (err)
 700                 return 1;
 701
 702         /* Step 2a : make sure trigger sources are unique */
 703
 704         err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
 705         err |= cfc_check_trigger_is_unique(cmd->stop_src);
 706
 707         /* Step 2b : and mutually compatible */
 708
 709         if (err)
 710                 return 2;
 711
 712         /* Step 3: check if arguments are trivially valid */
 713
 714         err |= cfc_check_trigger_arg_is(&cmd->start_arg, 0);
 715
 716         if (cmd->scan_begin_src == TRIG_FOLLOW) {
 717                 /* internal trigger */
 718                 err |= cfc_check_trigger_arg_is(&cmd->scan_begin_arg, 0);
 719         } else {
 720                 /* external trigger */
 721                 /* should be level/edge, hi/lo specification here */
 722                 err |= cfc_check_trigger_arg_is(&cmd->scan_begin_arg, 0);
 723         }
 724
 725         err |= cfc_check_trigger_arg_min(&cmd->convert_arg, 4000);
 726
 727 #define SLOWEST_TIMER   (250*(1<<15)*255)
 728         err |= cfc_check_trigger_arg_max(&cmd->convert_arg, SLOWEST_TIMER);
 729         err |= cfc_check_trigger_arg_min(&cmd->convert_arg, board->ai_speed);
 730         err |= cfc_check_trigger_arg_is(&cmd->scan_end_arg, cmd->chanlist_len);
 731
 732         if (cmd->stop_src == TRIG_COUNT)
 733                 err |= cfc_check_trigger_arg_min(&cmd->stop_arg, 1);
 734         else    /* TRIG_EXT | TRIG_NONE */
 735                 err |= cfc_check_trigger_arg_is(&cmd->stop_arg, 0);
 736
 737         if (err)
 738                 return 3;
 739
 740         /* step 4: fix up any arguments */
 741
 742         arg = cmd->convert_arg;
 743         devpriv->divisor = dt282x_ns_to_timer(&arg, cmd->flags);
 744         err |= cfc_check_trigger_arg_is(&cmd->convert_arg, arg);
 745
 746         if (err)
 747                 return 4;
 748
 749         return 0;
 750 }
 751
 752 static int dt282x_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
 753 {
 754         struct dt282x_private *devpriv = dev->private;
 755         struct comedi_cmd *cmd = &s->async->cmd;
 756         int ret;
 757
 758         dt282x_disable_dma(dev);
 759
 760         outw(devpriv->divisor, dev->iobase + DT2821_TMRCTR_REG);
 761
 762         devpriv->supcsr = DT2821_SUPCSR_ERRINTEN;
 763         if (cmd->scan_begin_src == TRIG_FOLLOW)
 764                 devpriv->supcsr = DT2821_SUPCSR_DS_AD_CLK;
 765         else
 766                 devpriv->supcsr = DT2821_SUPCSR_DS_AD_TRIG;
 767         outw(devpriv->supcsr |
 768              DT2821_SUPCSR_CLRDMADNE |
 769              DT2821_SUPCSR_BUFFB |
 770              DT2821_SUPCSR_ADCINIT,
 771              dev->iobase + DT2821_SUPCSR_REG);
 772
 773         devpriv->ntrig = cmd->stop_arg * cmd->scan_end_arg;
 774         devpriv->nread = devpriv->ntrig;
 775
 776         devpriv->dma_dir = DMA_MODE_READ;
 777         devpriv->cur_dma = 0;
 778         dt282x_prep_ai_dma(dev, 0, 0);
 779         if (devpriv->ntrig) {
 780                 dt282x_prep_ai_dma(dev, 1, 0);
 781                 devpriv->supcsr |= DT2821_SUPCSR_DDMA;
 782                 outw(devpriv->supcsr, dev->iobase + DT2821_SUPCSR_REG);
 783         }
 784
 785         devpriv->adcsr = 0;
 786
 787         dt282x_load_changain(dev, cmd->chanlist_len, cmd->chanlist);
 788
 789         devpriv->adcsr = DT2821_ADCSR_ADCLK | DT2821_ADCSR_IADDONE;
 790         outw(devpriv->adcsr, dev->iobase + DT2821_ADCSR_REG);
 791
 792         outw(devpriv->supcsr | DT2821_SUPCSR_PRLD,
 793              dev->iobase + DT2821_SUPCSR_REG);
 794         ret = comedi_timeout(dev, s, NULL,
 795                              dt282x_ai_timeout, DT2821_ADCSR_MUXBUSY);
 796         if (ret)
 797                 return ret;
 798
 799         if (cmd->scan_begin_src == TRIG_FOLLOW) {
 800                 outw(devpriv->supcsr | DT2821_SUPCSR_STRIG,
 801                         dev->iobase + DT2821_SUPCSR_REG);
 802         } else {
 803                 devpriv->supcsr |= DT2821_SUPCSR_XTRIG;
 804                 outw(devpriv->supcsr, dev->iobase + DT2821_SUPCSR_REG);
 805         }
 806
 807         return 0;
 808 }
 809
 810 static int dt282x_ai_cancel(struct comedi_device *dev,
 811                             struct comedi_subdevice *s)
 812 {
 813         struct dt282x_private *devpriv = dev->private;
 814
 815         dt282x_disable_dma(dev);
 816
 817         devpriv->adcsr = 0;
 818         outw(devpriv->adcsr, dev->iobase + DT2821_ADCSR_REG);
 819
 820         devpriv->supcsr = 0;
 821         outw(devpriv->supcsr | DT2821_SUPCSR_ADCINIT,
 822              dev->iobase + DT2821_SUPCSR_REG);
 823
 824         return 0;
 825 }
 826
 827 static int dt282x_ao_insn_write(struct comedi_device *dev,
 828                                 struct comedi_subdevice *s,
 829                                 struct comedi_insn *insn,
 830                                 unsigned int *data)
 831 {
 832         struct dt282x_private *devpriv = dev->private;
 833         unsigned int chan = CR_CHAN(insn->chanspec);
 834         unsigned int range = CR_RANGE(insn->chanspec);
 835         int i;
 836
 837         devpriv->dacsr |= DT2821_DACSR_SSEL | DT2821_DACSR_YSEL(chan);
 838
 839         for (i = 0; i < insn->n; i++) {
 840                 unsigned int val = data[i];
 841
 842                 s->readback[chan] = val;
 843
 844                 if (comedi_range_is_bipolar(s, range))
 845                         val = comedi_offset_munge(s, val);
 846
 847                 outw(devpriv->dacsr, dev->iobase + DT2821_DACSR_REG);
 848
 849                 outw(val, dev->iobase + DT2821_DADAT_REG);
 850
 851                 outw(devpriv->supcsr | DT2821_SUPCSR_DACON,
 852                      dev->iobase + DT2821_SUPCSR_REG);
 853         }
 854
 855         return insn->n;
 856 }
 857
 858 static int dt282x_ao_cmdtest(struct comedi_device *dev,
 859                              struct comedi_subdevice *s,
 860                              struct comedi_cmd *cmd)
 861 {
 862         struct dt282x_private *devpriv = dev->private;
 863         int err = 0;
 864         unsigned int arg;
 865
 866         /* Step 1 : check if triggers are trivially valid */
 867
 868         err |= cfc_check_trigger_src(&cmd->start_src, TRIG_INT);
 869         err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_TIMER);
 870         err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW);
 871         err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
 872         err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
 873
 874         if (err)
 875                 return 1;
 876
 877         /* Step 2a : make sure trigger sources are unique */
 878
 879         err |= cfc_check_trigger_is_unique(cmd->stop_src);
 880
 881         /* Step 2b : and mutually compatible */
 882
 883         if (err)
 884                 return 2;
 885
 886         /* Step 3: check if arguments are trivially valid */
 887
 888         err |= cfc_check_trigger_arg_is(&cmd->start_arg, 0);
 889         err |= cfc_check_trigger_arg_min(&cmd->scan_begin_arg, 5000);
 890         err |= cfc_check_trigger_arg_is(&cmd->convert_arg, 0);
 891         err |= cfc_check_trigger_arg_is(&cmd->scan_end_arg, cmd->chanlist_len);
 892
 893         if (cmd->stop_src == TRIG_COUNT)
 894                 err |= cfc_check_trigger_arg_min(&cmd->stop_arg, 1);
 895         else    /* TRIG_EXT | TRIG_NONE */
 896                 err |= cfc_check_trigger_arg_is(&cmd->stop_arg, 0);
 897
 898         if (err)
 899                 return 3;
 900
 901         /* step 4: fix up any arguments */
 902
 903         arg = cmd->scan_begin_arg;
 904         devpriv->divisor = dt282x_ns_to_timer(&arg, cmd->flags);
 905         err |= cfc_check_trigger_arg_is(&cmd->scan_begin_arg, arg);
 906
 907         if (err)
 908                 return 4;
 909
 910         return 0;
 911
 912 }
 913
 914 static int dt282x_ao_inttrig(struct comedi_device *dev,
 915                              struct comedi_subdevice *s,
 916                              unsigned int trig_num)
 917 {
 918         struct dt282x_private *devpriv = dev->private;
 919         struct comedi_cmd *cmd = &s->async->cmd;
 920
 921         if (trig_num != cmd->start_src)
 922                 return -EINVAL;
 923
 924         if (!dt282x_ao_setup_dma(dev, s, 0))
 925                 return -EPIPE;
 926
 927         if (!dt282x_ao_setup_dma(dev, s, 1))
 928                 return -EPIPE;
 929
 930         outw(devpriv->supcsr | DT2821_SUPCSR_STRIG,
 931              dev->iobase + DT2821_SUPCSR_REG);
 932         s->async->inttrig = NULL;
 933
 934         return 1;
 935 }
 936
 937 static int dt282x_ao_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
 938 {
 939         struct dt282x_private *devpriv = dev->private;
 940         struct comedi_cmd *cmd = &s->async->cmd;
 941
 942         dt282x_disable_dma(dev);
 943
 944         devpriv->supcsr = DT2821_SUPCSR_ERRINTEN |
 945                           DT2821_SUPCSR_DS_DA_CLK |
 946                           DT2821_SUPCSR_DDMA;
 947         outw(devpriv->supcsr |
 948              DT2821_SUPCSR_CLRDMADNE |
 949              DT2821_SUPCSR_BUFFB |
 950              DT2821_SUPCSR_DACINIT,
 951              dev->iobase + DT2821_SUPCSR_REG);
 952
 953         devpriv->ntrig = cmd->stop_arg * cmd->chanlist_len;
 954         devpriv->nread = devpriv->ntrig;
 955
 956         devpriv->dma_dir = DMA_MODE_WRITE;
 957         devpriv->cur_dma = 0;
 958
 959         outw(devpriv->divisor, dev->iobase + DT2821_TMRCTR_REG);
 960
 961         /* clear all bits but the DIO direction bits */
 962         devpriv->dacsr &= (DT2821_DACSR_LBOE | DT2821_DACSR_HBOE);
 963
 964         devpriv->dacsr |= (DT2821_DACSR_SSEL |
 965                            DT2821_DACSR_DACLK |
 966                            DT2821_DACSR_IDARDY);
 967         outw(devpriv->dacsr, dev->iobase + DT2821_DACSR_REG);
 968
 969         s->async->inttrig = dt282x_ao_inttrig;
 970
 971         return 0;
 972 }
 973
 974 static int dt282x_ao_cancel(struct comedi_device *dev,
 975                             struct comedi_subdevice *s)
 976 {
 977         struct dt282x_private *devpriv = dev->private;
 978
 979         dt282x_disable_dma(dev);
 980
 981         /* clear all bits but the DIO direction bits */
 982         devpriv->dacsr &= (DT2821_DACSR_LBOE | DT2821_DACSR_HBOE);
 983
 984         outw(devpriv->dacsr, dev->iobase + DT2821_DACSR_REG);
 985
 986         devpriv->supcsr = 0;
 987         outw(devpriv->supcsr | DT2821_SUPCSR_DACINIT,
 988              dev->iobase + DT2821_SUPCSR_REG);
 989
 990         return 0;
 991 }
 992
 993 static int dt282x_dio_insn_bits(struct comedi_device *dev,
 994                                 struct comedi_subdevice *s,
 995                                 struct comedi_insn *insn,
 996                                 unsigned int *data)
 997 {
 998         if (comedi_dio_update_state(s, data))
 999                 outw(s->state, dev->iobase + DT2821_DIODAT_REG);
1000
1001         data[1] = inw(dev->iobase + DT2821_DIODAT_REG);
1002
1003         return insn->n;
1004 }
1005
1006 static int dt282x_dio_insn_config(struct comedi_device *dev,
1007                                   struct comedi_subdevice *s,
1008                                   struct comedi_insn *insn,
1009                                   unsigned int *data)
1010 {
1011         struct dt282x_private *devpriv = dev->private;
1012         unsigned int chan = CR_CHAN(insn->chanspec);
1013         unsigned int mask;
1014         int ret;
1015
1016         if (chan < 8)
1017                 mask = 0x00ff;
1018         else
1019                 mask = 0xff00;
1020
1021         ret = comedi_dio_insn_config(dev, s, insn, data, mask);
1022         if (ret)
1023                 return ret;
1024
1025         devpriv->dacsr &= ~(DT2821_DACSR_LBOE | DT2821_DACSR_HBOE);
1026         if (s->io_bits & 0x00ff)
1027                 devpriv->dacsr |= DT2821_DACSR_LBOE;
1028         if (s->io_bits & 0xff00)
1029                 devpriv->dacsr |= DT2821_DACSR_HBOE;
1030
1031         outw(devpriv->dacsr, dev->iobase + DT2821_DACSR_REG);
1032
1033         return insn->n;
1034 }
1035
1036 static const struct comedi_lrange *const ai_range_table[] = {
1037         &range_dt282x_ai_lo_bipolar,
1038         &range_dt282x_ai_lo_unipolar,
1039         &range_dt282x_ai_5_bipolar,
1040         &range_dt282x_ai_5_unipolar
1041 };
1042
1043 static const struct comedi_lrange *const ai_range_pgl_table[] = {
1044         &range_dt282x_ai_hi_bipolar,
1045         &range_dt282x_ai_hi_unipolar
1046 };
1047
1048 static const struct comedi_lrange *opt_ai_range_lkup(int ispgl, int x)
1049 {
1050         if (ispgl) {
1051                 if (x < 0 || x >= 2)
1052                         x = 0;
1053                 return ai_range_pgl_table[x];
1054         }
1055
1056         if (x < 0 || x >= 4)
1057                 x = 0;
1058         return ai_range_table[x];
1059 }
1060
1061 static int dt282x_alloc_dma(struct comedi_device *dev,
1062                             struct comedi_devconfig *it)
1063 {
1064         struct dt282x_private *devpriv = dev->private;
1065         unsigned int irq_num = it->options[1];
1066         unsigned int dma_chan[2];
1067         int i;
1068
1069         if (it->options[2] < it->options[3]) {
1070                 dma_chan[0] = it->options[2];
1071                 dma_chan[1] = it->options[3];
1072         } else {
1073                 dma_chan[0] = it->options[3];
1074                 dma_chan[1] = it->options[2];
1075         }
1076
1077         if (!irq_num || dma_chan[0] == dma_chan[1] ||
1078             dma_chan[0] < 5 || dma_chan[0] > 7 ||
1079             dma_chan[1] < 5 || dma_chan[1] > 7)
1080                 return 0;
1081
1082         if (request_irq(irq_num, dt282x_interrupt, 0, dev->board_name, dev))
1083                 return 0;
1084         if (request_dma(dma_chan[0], dev->board_name)) {
1085                 free_irq(irq_num, dev);
1086                 return 0;
1087         }
1088         if (request_dma(dma_chan[1], dev->board_name)) {
1089                 free_dma(dma_chan[0]);
1090                 free_irq(irq_num, dev);
1091                 return 0;
1092         }
1093
1094         dev->irq = irq_num;
1095
1096         devpriv->dma_maxsize = PAGE_SIZE;
1097         for (i = 0; i < 2; i++) {
1098                 struct dt282x_dma_desc *dma = &devpriv->dma_desc[i];
1099
1100                 dma->chan = dma_chan[i];
1101                 dma->virt_addr = dma_alloc_coherent(NULL, devpriv->dma_maxsize,
1102                                                     &dma->hw_addr, GFP_KERNEL);
1103                 if (!dma->virt_addr)
1104                         return -ENOMEM;
1105         }
1106
1107         return 0;
1108 }
1109
1110 static void dt282x_free_dma(struct comedi_device *dev)
1111 {
1112         struct dt282x_private *devpriv = dev->private;
1113         struct dt282x_dma_desc *dma;
1114         int i;
1115
1116         if (!devpriv)
1117                 return;
1118
1119         for (i = 0; i < 2; i++) {
1120                 dma = &devpriv->dma_desc[i];
1121                 if (dma->chan)
1122                         free_dma(dma->chan);
1123                 if (dma->virt_addr)
1124                         dma_free_coherent(NULL, devpriv->dma_maxsize,
1125                                           dma->virt_addr, dma->hw_addr);
1126         }
1127 }
1128
1129 static int dt282x_initialize(struct comedi_device *dev)
1130 {
1131         /* Initialize board */
1132         outw(DT2821_SUPCSR_BDINIT, dev->iobase + DT2821_SUPCSR_REG);
1133         inw(dev->iobase + DT2821_ADCSR_REG);
1134
1135         /*
1136          * At power up, some registers are in a well-known state.
1137          * Check them to see if a DT2821 series board is present.
1138          */
1139         if (((inw(dev->iobase + DT2821_ADCSR_REG) & 0xfff0) != 0x7c00) ||
1140             ((inw(dev->iobase + DT2821_CHANCSR_REG) & 0xf0f0) != 0x70f0) ||
1141             ((inw(dev->iobase + DT2821_DACSR_REG) & 0x7c93) != 0x7c90) ||
1142             ((inw(dev->iobase + DT2821_SUPCSR_REG) & 0xf8ff) != 0x0000) ||
1143             ((inw(dev->iobase + DT2821_TMRCTR_REG) & 0xff00) != 0xf000)) {
1144                 dev_err(dev->class_dev, "board not found\n");
1145                 return -EIO;
1146         }
1147         return 0;
1148 }
1149
1150 /*
1151    options:
1152    0    i/o base
1153    1    irq
1154    2    dma1
1155    3    dma2
1156    4    0=single ended, 1=differential
1157    5    ai 0=straight binary, 1=2's comp
1158    6    ao0 0=straight binary, 1=2's comp
1159    7    ao1 0=straight binary, 1=2's comp
1160    8    ai 0=±10 V, 1=0-10 V, 2=±5 V, 3=0-5 V
1161    9    ao0 0=±10 V, 1=0-10 V, 2=±5 V, 3=0-5 V, 4=±2.5 V
1162    10   ao1 0=±10 V, 1=0-10 V, 2=±5 V, 3=0-5 V, 4=±2.5 V
1163  */
1164 static int dt282x_attach(struct comedi_device *dev, struct comedi_devconfig *it)
1165 {
1166         const struct dt282x_board *board = dev->board_ptr;
1167         struct dt282x_private *devpriv;
1168         struct comedi_subdevice *s;
1169         int ret;
1170
1171         ret = comedi_request_region(dev, it->options[0], 0x10);
1172         if (ret)
1173                 return ret;
1174
1175         ret = dt282x_initialize(dev);
1176         if (ret)
1177                 return ret;
1178
1179         devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
1180         if (!devpriv)
1181                 return -ENOMEM;
1182
1183         /* an IRQ and 2 DMA channels are required for async command support */
1184         ret = dt282x_alloc_dma(dev, it);
1185         if (ret)
1186                 return ret;
1187
1188         ret = comedi_alloc_subdevices(dev, 3);
1189         if (ret)
1190                 return ret;
1191
1192         /* Analog Input subdevice */
1193         s = &dev->subdevices[0];
1194         s->type         = COMEDI_SUBD_AI;
1195         s->subdev_flags = SDF_READABLE;
1196         if ((it->options[4] && board->adchan_di) || board->adchan_se == 0) {
1197                 s->subdev_flags |= SDF_DIFF;
1198                 s->n_chan       = board->adchan_di;
1199         } else {
1200                 s->subdev_flags |= SDF_COMMON;
1201                 s->n_chan       = board->adchan_se;
1202         }
1203         s->maxdata      = board->ai_maxdata;
1204
1205         s->range_table = opt_ai_range_lkup(board->ispgl, it->options[8]);
1206         devpriv->ad_2scomp = it->options[5] ? 1 : 0;
1207
1208         s->insn_read    = dt282x_ai_insn_read;
1209         if (dev->irq) {
1210                 dev->read_subdev = s;
1211                 s->subdev_flags |= SDF_CMD_READ;
1212                 s->len_chanlist = s->n_chan;
1213                 s->do_cmdtest   = dt282x_ai_cmdtest;
1214                 s->do_cmd       = dt282x_ai_cmd;
1215                 s->cancel       = dt282x_ai_cancel;
1216         }
1217
1218         /* Analog Output subdevice */
1219         s = &dev->subdevices[1];
1220         if (board->dachan) {
1221                 s->type         = COMEDI_SUBD_AO;
1222                 s->subdev_flags = SDF_WRITABLE;
1223                 s->n_chan       = board->dachan;
1224                 s->maxdata      = board->ao_maxdata;
1225                 /* ranges are per-channel, set by jumpers on the board */
1226                 s->range_table  = &dt282x_ao_range;
1227                 s->insn_write   = dt282x_ao_insn_write;
1228                 if (dev->irq) {
1229                         dev->write_subdev = s;
1230                         s->subdev_flags |= SDF_CMD_WRITE;
1231                         s->len_chanlist = s->n_chan;
1232                         s->do_cmdtest   = dt282x_ao_cmdtest;
1233                         s->do_cmd       = dt282x_ao_cmd;
1234                         s->cancel       = dt282x_ao_cancel;
1235                 }
1236
1237                 ret = comedi_alloc_subdev_readback(s);
1238                 if (ret)
1239                         return ret;
1240         } else {
1241                 s->type         = COMEDI_SUBD_UNUSED;
1242         }
1243
1244         /* Digital I/O subdevice */
1245         s = &dev->subdevices[2];
1246         s->type         = COMEDI_SUBD_DIO;
1247         s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
1248         s->n_chan       = 16;
1249         s->maxdata      = 1;
1250         s->range_table  = &range_digital;
1251         s->insn_bits    = dt282x_dio_insn_bits;
1252         s->insn_config  = dt282x_dio_insn_config;
1253
1254         return 0;
1255 }
1256
1257 static void dt282x_detach(struct comedi_device *dev)
1258 {
1259         dt282x_free_dma(dev);
1260         comedi_legacy_detach(dev);
1261 }
1262
1263 static struct comedi_driver dt282x_driver = {
1264         .driver_name    = "dt282x",
1265         .module         = THIS_MODULE,
1266         .attach         = dt282x_attach,
1267         .detach         = dt282x_detach,
1268         .board_name     = &boardtypes[0].name,
1269         .num_names      = ARRAY_SIZE(boardtypes),
1270         .offset         = sizeof(struct dt282x_board),
1271 };
1272 module_comedi_driver(dt282x_driver);
1273
1274 MODULE_AUTHOR("Comedi http://www.comedi.org");
1275 MODULE_DESCRIPTION("Comedi driver for Data Translation DT2821 series");
1276 MODULE_LICENSE("GPL");