drivers/staging/comedi/drivers/ni_at_a2150.c

   1 /*
   2     comedi/drivers/ni_at_a2150.c
   3     Driver for National Instruments AT-A2150 boards
   4     Copyright (C) 2001, 2002 Frank Mori Hess <fmhess@users.sourceforge.net>
   5
   6     COMEDI - Linux Control and Measurement Device Interface
   7     Copyright (C) 2000 David A. Schleef <ds@schleef.org>
   8
   9     This program is free software; you can redistribute it and/or modify
  10     it under the terms of the GNU General Public License as published by
  11     the Free Software Foundation; either version 2 of the License, or
  12     (at your option) any later version.
  13
  14     This program is distributed in the hope that it will be useful,
  15     but WITHOUT ANY WARRANTY; without even the implied warranty of
  16     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17     GNU General Public License for more details.
  18 */
  19 /*
  20 Driver: ni_at_a2150
  21 Description: National Instruments AT-A2150
  22 Author: Frank Mori Hess
  23 Status: works
  24 Devices: [National Instruments] AT-A2150C (at_a2150c), AT-2150S (at_a2150s)
  25
  26 If you want to ac couple the board's inputs, use AREF_OTHER.
  27
  28 Configuration options:
  29   [0] - I/O port base address
  30   [1] - IRQ (optional, required for timed conversions)
  31   [2] - DMA (optional, required for timed conversions)
  32
  33 */
  34 /*
  35 Yet another driver for obsolete hardware brought to you by Frank Hess.
  36 Testing and debugging help provided by Dave Andruczyk.
  37
  38 This driver supports the boards:
  39
  40 AT-A2150C
  41 AT-A2150S
  42
  43 The only difference is their master clock frequencies.
  44
  45 Options:
  46         [0] - base io address
  47         [1] - irq
  48         [2] - dma channel
  49
  50 References (from ftp://ftp.natinst.com/support/manuals):
  51
  52            320360.pdf  AT-A2150 User Manual
  53
  54 TODO:
  55
  56 analog level triggering
  57 TRIG_WAKE_EOS
  58
  59 */
  60
  61 #include <linux/interrupt.h>
  62 #include <linux/slab.h>
  63 #include "../comedidev.h"
  64
  65 #include <linux/ioport.h>
  66 #include <linux/io.h>
  67 #include <asm/dma.h>
  68
  69 #include "8253.h"
  70 #include "comedi_fc.h"
  71
  72 #define A2150_SIZE           28
  73 #define A2150_DMA_BUFFER_SIZE   0xff00  /*  size in bytes of dma buffer */
  74
  75 /* #define A2150_DEBUG     enable debugging code */
  76 #undef A2150_DEBUG              /*  disable debugging code */
  77
  78 /* Registers and bits */
  79 #define CONFIG_REG              0x0
  80 #define   CHANNEL_BITS(x)               ((x) & 0x7)
  81 #define   CHANNEL_MASK          0x7
  82 #define   CLOCK_SELECT_BITS(x)          (((x) & 0x3) << 3)
  83 #define   CLOCK_DIVISOR_BITS(x)         (((x) & 0x3) << 5)
  84 #define   CLOCK_MASK            (0xf << 3)
  85 #define   ENABLE0_BIT           0x80    /*  enable (don't internally ground) channels 0 and 1 */
  86 #define   ENABLE1_BIT           0x100   /*  enable (don't internally ground) channels 2 and 3 */
  87 #define   AC0_BIT               0x200   /*  ac couple channels 0,1 */
  88 #define   AC1_BIT               0x400   /*  ac couple channels 2,3 */
  89 #define   APD_BIT               0x800   /*  analog power down */
  90 #define   DPD_BIT               0x1000  /*  digital power down */
  91 #define TRIGGER_REG             0x2     /*  trigger config register */
  92 #define   POST_TRIGGER_BITS             0x2
  93 #define   DELAY_TRIGGER_BITS            0x3
  94 #define   HW_TRIG_EN            0x10    /*  enable hardware trigger */
  95 #define FIFO_START_REG          0x6     /*  software start aquistion trigger */
  96 #define FIFO_RESET_REG          0x8     /*  clears fifo + fifo flags */
  97 #define FIFO_DATA_REG           0xa     /*  read data */
  98 #define DMA_TC_CLEAR_REG                0xe     /*  clear dma terminal count interrupt */
  99 #define STATUS_REG              0x12    /*  read only */
 100 #define   FNE_BIT               0x1     /*  fifo not empty */
 101 #define   OVFL_BIT              0x8     /*  fifo overflow */
 102 #define   EDAQ_BIT              0x10    /*  end of acquisition interrupt */
 103 #define   DCAL_BIT              0x20    /*  offset calibration in progress */
 104 #define   INTR_BIT              0x40    /*  interrupt has occurred */
 105 #define   DMA_TC_BIT            0x80    /*  dma terminal count interrupt has occurred */
 106 #define   ID_BITS(x)    (((x) >> 8) & 0x3)
 107 #define IRQ_DMA_CNTRL_REG               0x12    /*  write only */
 108 #define   DMA_CHAN_BITS(x)              ((x) & 0x7)     /*  sets dma channel */
 109 #define   DMA_EN_BIT            0x8     /*  enables dma */
 110 #define   IRQ_LVL_BITS(x)               (((x) & 0xf) << 4)      /*  sets irq level */
 111 #define   FIFO_INTR_EN_BIT              0x100   /*  enable fifo interrupts */
 112 #define   FIFO_INTR_FHF_BIT             0x200   /*  interrupt fifo half full */
 113 #define   DMA_INTR_EN_BIT               0x800   /*  enable interrupt on dma terminal count */
 114 #define   DMA_DEM_EN_BIT        0x1000  /*  enables demand mode dma */
 115 #define I8253_BASE_REG          0x14
 116 #define I8253_MODE_REG          0x17
 117 #define   HW_COUNT_DISABLE              0x30    /*  disable hardware counting of conversions */
 118
 119 struct a2150_board {
 120         const char *name;
 121         int clock[4];           /*  master clock periods, in nanoseconds */
 122         int num_clocks;         /*  number of available master clock speeds */
 123         int ai_speed;           /*  maximum conversion rate in nanoseconds */
 124 };
 125
 126 /* analog input range */
 127 static const struct comedi_lrange range_a2150 = {
 128         1,
 129         {
 130          RANGE(-2.828, 2.828),
 131          }
 132 };
 133
 134 /* enum must match board indices */
 135 enum { a2150_c, a2150_s };
 136 static const struct a2150_board a2150_boards[] = {
 137         {
 138          .name = "at-a2150c",
 139          .clock = {31250, 22676, 20833, 19531},
 140          .num_clocks = 4,
 141          .ai_speed = 19531,
 142          },
 143         {
 144          .name = "at-a2150s",
 145          .clock = {62500, 50000, 41667, 0},
 146          .num_clocks = 3,
 147          .ai_speed = 41667,
 148          },
 149 };
 150
 151 struct a2150_private {
 152
 153         volatile unsigned int count;    /* number of data points left to be taken */
 154         unsigned int dma;       /*  dma channel */
 155         s16 *dma_buffer;        /*  dma buffer */
 156         unsigned int dma_transfer_size; /*  size in bytes of dma transfers */
 157         int irq_dma_bits;       /*  irq/dma register bits */
 158         int config_bits;        /*  config register bits */
 159 };
 160
 161 static int a2150_cancel(struct comedi_device *dev, struct comedi_subdevice *s);
 162
 163 static int a2150_get_timing(struct comedi_device *dev, unsigned int *period,
 164                             int flags);
 165 static int a2150_set_chanlist(struct comedi_device *dev,
 166                               unsigned int start_channel,
 167                               unsigned int num_channels);
 168 #ifdef A2150_DEBUG
 169
 170 static void ni_dump_regs(struct comedi_device *dev)
 171 {
 172         struct a2150_private *devpriv = dev->private;
 173
 174         printk("config bits 0x%x\n", devpriv->config_bits);
 175         printk("irq dma bits 0x%x\n", devpriv->irq_dma_bits);
 176         printk("status bits 0x%x\n", inw(dev->iobase + STATUS_REG));
 177 }
 178
 179 #endif
 180
 181 /* interrupt service routine */
 182 static irqreturn_t a2150_interrupt(int irq, void *d)
 183 {
 184         int i;
 185         int status;
 186         unsigned long flags;
 187         struct comedi_device *dev = d;
 188         struct a2150_private *devpriv = dev->private;
 189         struct comedi_subdevice *s = dev->read_subdev;
 190         struct comedi_async *async;
 191         struct comedi_cmd *cmd;
 192         unsigned int max_points, num_points, residue, leftover;
 193         short dpnt;
 194         static const int sample_size = sizeof(devpriv->dma_buffer[0]);
 195
 196         if (!dev->attached) {
 197                 comedi_error(dev, "premature interrupt");
 198                 return IRQ_HANDLED;
 199         }
 200         /*  initialize async here to make sure s is not NULL */
 201         async = s->async;
 202         async->events = 0;
 203         cmd = &async->cmd;
 204
 205         status = inw(dev->iobase + STATUS_REG);
 206
 207         if ((status & INTR_BIT) == 0) {
 208                 comedi_error(dev, "spurious interrupt");
 209                 return IRQ_NONE;
 210         }
 211
 212         if (status & OVFL_BIT) {
 213                 comedi_error(dev, "fifo overflow");
 214                 a2150_cancel(dev, s);
 215                 async->events |= COMEDI_CB_ERROR | COMEDI_CB_EOA;
 216         }
 217
 218         if ((status & DMA_TC_BIT) == 0) {
 219                 comedi_error(dev, "caught non-dma interrupt?  Aborting.");
 220                 a2150_cancel(dev, s);
 221                 async->events |= COMEDI_CB_ERROR | COMEDI_CB_EOA;
 222                 comedi_event(dev, s);
 223                 return IRQ_HANDLED;
 224         }
 225
 226         flags = claim_dma_lock();
 227         disable_dma(devpriv->dma);
 228         /* clear flip-flop to make sure 2-byte registers for
 229          * count and address get set correctly */
 230         clear_dma_ff(devpriv->dma);
 231
 232         /*  figure out how many points to read */
 233         max_points = devpriv->dma_transfer_size / sample_size;
 234         /* residue is the number of points left to be done on the dma
 235          * transfer.  It should always be zero at this point unless
 236          * the stop_src is set to external triggering.
 237          */
 238         residue = get_dma_residue(devpriv->dma) / sample_size;
 239         num_points = max_points - residue;
 240         if (devpriv->count < num_points && cmd->stop_src == TRIG_COUNT)
 241                 num_points = devpriv->count;
 242
 243         /*  figure out how many points will be stored next time */
 244         leftover = 0;
 245         if (cmd->stop_src == TRIG_NONE) {
 246                 leftover = devpriv->dma_transfer_size / sample_size;
 247         } else if (devpriv->count > max_points) {
 248                 leftover = devpriv->count - max_points;
 249                 if (leftover > max_points)
 250                         leftover = max_points;
 251         }
 252         /* there should only be a residue if collection was stopped by having
 253          * the stop_src set to an external trigger, in which case there
 254          * will be no more data
 255          */
 256         if (residue)
 257                 leftover = 0;
 258
 259         for (i = 0; i < num_points; i++) {
 260                 /* write data point to comedi buffer */
 261                 dpnt = devpriv->dma_buffer[i];
 262                 /*  convert from 2's complement to unsigned coding */
 263                 dpnt ^= 0x8000;
 264                 cfc_write_to_buffer(s, dpnt);
 265                 if (cmd->stop_src == TRIG_COUNT) {
 266                         if (--devpriv->count == 0) {    /* end of acquisition */
 267                                 a2150_cancel(dev, s);
 268                                 async->events |= COMEDI_CB_EOA;
 269                                 break;
 270                         }
 271                 }
 272         }
 273         /*  re-enable  dma */
 274         if (leftover) {
 275                 set_dma_addr(devpriv->dma, virt_to_bus(devpriv->dma_buffer));
 276                 set_dma_count(devpriv->dma, leftover * sample_size);
 277                 enable_dma(devpriv->dma);
 278         }
 279         release_dma_lock(flags);
 280
 281         async->events |= COMEDI_CB_BLOCK;
 282
 283         comedi_event(dev, s);
 284
 285         /* clear interrupt */
 286         outw(0x00, dev->iobase + DMA_TC_CLEAR_REG);
 287
 288         return IRQ_HANDLED;
 289 }
 290
 291 static int a2150_cancel(struct comedi_device *dev, struct comedi_subdevice *s)
 292 {
 293         struct a2150_private *devpriv = dev->private;
 294
 295         /*  disable dma on card */
 296         devpriv->irq_dma_bits &= ~DMA_INTR_EN_BIT & ~DMA_EN_BIT;
 297         outw(devpriv->irq_dma_bits, dev->iobase + IRQ_DMA_CNTRL_REG);
 298
 299         /*  disable computer's dma */
 300         disable_dma(devpriv->dma);
 301
 302         /*  clear fifo and reset triggering circuitry */
 303         outw(0, dev->iobase + FIFO_RESET_REG);
 304
 305         return 0;
 306 }
 307
 308 static int a2150_ai_cmdtest(struct comedi_device *dev,
 309                             struct comedi_subdevice *s, struct comedi_cmd *cmd)
 310 {
 311         const struct a2150_board *thisboard = comedi_board(dev);
 312         int err = 0;
 313         int tmp;
 314         int startChan;
 315         int i;
 316
 317         /* Step 1 : check if triggers are trivially valid */
 318
 319         err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_EXT);
 320         err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_TIMER);
 321         err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW);
 322         err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
 323         err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
 324
 325         if (err)
 326                 return 1;
 327
 328         /* Step 2a : make sure trigger sources are unique */
 329
 330         err |= cfc_check_trigger_is_unique(cmd->start_src);
 331         err |= cfc_check_trigger_is_unique(cmd->stop_src);
 332
 333         /* Step 2b : and mutually compatible */
 334
 335         if (err)
 336                 return 2;
 337
 338         /* Step 3: check if arguments are trivially valid */
 339
 340         err |= cfc_check_trigger_arg_is(&cmd->start_arg, 0);
 341
 342         if (cmd->convert_src == TRIG_TIMER)
 343                 err |= cfc_check_trigger_arg_min(&cmd->convert_arg,
 344                                                  thisboard->ai_speed);
 345
 346         err |= cfc_check_trigger_arg_min(&cmd->chanlist_len, 1);
 347         err |= cfc_check_trigger_arg_is(&cmd->scan_end_arg, cmd->chanlist_len);
 348
 349         if (cmd->stop_src == TRIG_COUNT)
 350                 err |= cfc_check_trigger_arg_min(&cmd->stop_arg, 1);
 351         else    /* TRIG_NONE */
 352                 err |= cfc_check_trigger_arg_is(&cmd->stop_arg, 0);
 353
 354         if (err)
 355                 return 3;
 356
 357         /* step 4: fix up any arguments */
 358
 359         if (cmd->scan_begin_src == TRIG_TIMER) {
 360                 tmp = cmd->scan_begin_arg;
 361                 a2150_get_timing(dev, &cmd->scan_begin_arg, cmd->flags);
 362                 if (tmp != cmd->scan_begin_arg)
 363                         err++;
 364         }
 365
 366         if (err)
 367                 return 4;
 368
 369         /*  check channel/gain list against card's limitations */
 370         if (cmd->chanlist) {
 371                 startChan = CR_CHAN(cmd->chanlist[0]);
 372                 for (i = 1; i < cmd->chanlist_len; i++) {
 373                         if (CR_CHAN(cmd->chanlist[i]) != (startChan + i)) {
 374                                 comedi_error(dev,
 375                                              "entries in chanlist must be consecutive channels, counting upwards\n");
 376                                 err++;
 377                         }
 378                 }
 379                 if (cmd->chanlist_len == 2 && CR_CHAN(cmd->chanlist[0]) == 1) {
 380                         comedi_error(dev,
 381                                      "length 2 chanlist must be channels 0,1 or channels 2,3");
 382                         err++;
 383                 }
 384                 if (cmd->chanlist_len == 3) {
 385                         comedi_error(dev,
 386                                      "chanlist must have 1,2 or 4 channels");
 387                         err++;
 388                 }
 389                 if (CR_AREF(cmd->chanlist[0]) != CR_AREF(cmd->chanlist[1]) ||
 390                     CR_AREF(cmd->chanlist[2]) != CR_AREF(cmd->chanlist[3])) {
 391                         comedi_error(dev,
 392                                      "channels 0/1 and 2/3 must have the same analog reference");
 393                         err++;
 394                 }
 395         }
 396
 397         if (err)
 398                 return 5;
 399
 400         return 0;
 401 }
 402
 403 static int a2150_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
 404 {
 405         struct a2150_private *devpriv = dev->private;
 406         struct comedi_async *async = s->async;
 407         struct comedi_cmd *cmd = &async->cmd;
 408         unsigned long lock_flags;
 409         unsigned int old_config_bits = devpriv->config_bits;
 410         unsigned int trigger_bits;
 411
 412         if (!dev->irq || !devpriv->dma) {
 413                 comedi_error(dev,
 414                              " irq and dma required, cannot do hardware conversions");
 415                 return -1;
 416         }
 417         if (cmd->flags & TRIG_RT) {
 418                 comedi_error(dev,
 419                              " dma incompatible with hard real-time interrupt (TRIG_RT), aborting");
 420                 return -1;
 421         }
 422         /*  clear fifo and reset triggering circuitry */
 423         outw(0, dev->iobase + FIFO_RESET_REG);
 424
 425         /* setup chanlist */
 426         if (a2150_set_chanlist(dev, CR_CHAN(cmd->chanlist[0]),
 427                                cmd->chanlist_len) < 0)
 428                 return -1;
 429
 430         /*  setup ac/dc coupling */
 431         if (CR_AREF(cmd->chanlist[0]) == AREF_OTHER)
 432                 devpriv->config_bits |= AC0_BIT;
 433         else
 434                 devpriv->config_bits &= ~AC0_BIT;
 435         if (CR_AREF(cmd->chanlist[2]) == AREF_OTHER)
 436                 devpriv->config_bits |= AC1_BIT;
 437         else
 438                 devpriv->config_bits &= ~AC1_BIT;
 439
 440         /*  setup timing */
 441         a2150_get_timing(dev, &cmd->scan_begin_arg, cmd->flags);
 442
 443         /*  send timing, channel, config bits */
 444         outw(devpriv->config_bits, dev->iobase + CONFIG_REG);
 445
 446         /*  initialize number of samples remaining */
 447         devpriv->count = cmd->stop_arg * cmd->chanlist_len;
 448
 449         /*  enable computer's dma */
 450         lock_flags = claim_dma_lock();
 451         disable_dma(devpriv->dma);
 452         /* clear flip-flop to make sure 2-byte registers for
 453          * count and address get set correctly */
 454         clear_dma_ff(devpriv->dma);
 455         set_dma_addr(devpriv->dma, virt_to_bus(devpriv->dma_buffer));
 456         /*  set size of transfer to fill in 1/3 second */
 457 #define ONE_THIRD_SECOND 333333333
 458         devpriv->dma_transfer_size =
 459             sizeof(devpriv->dma_buffer[0]) * cmd->chanlist_len *
 460             ONE_THIRD_SECOND / cmd->scan_begin_arg;
 461         if (devpriv->dma_transfer_size > A2150_DMA_BUFFER_SIZE)
 462                 devpriv->dma_transfer_size = A2150_DMA_BUFFER_SIZE;
 463         if (devpriv->dma_transfer_size < sizeof(devpriv->dma_buffer[0]))
 464                 devpriv->dma_transfer_size = sizeof(devpriv->dma_buffer[0]);
 465         devpriv->dma_transfer_size -=
 466             devpriv->dma_transfer_size % sizeof(devpriv->dma_buffer[0]);
 467         set_dma_count(devpriv->dma, devpriv->dma_transfer_size);
 468         enable_dma(devpriv->dma);
 469         release_dma_lock(lock_flags);
 470
 471         /* clear dma interrupt before enabling it, to try and get rid of that
 472          * one spurious interrupt that has been happening */
 473         outw(0x00, dev->iobase + DMA_TC_CLEAR_REG);
 474
 475         /*  enable dma on card */
 476         devpriv->irq_dma_bits |= DMA_INTR_EN_BIT | DMA_EN_BIT;
 477         outw(devpriv->irq_dma_bits, dev->iobase + IRQ_DMA_CNTRL_REG);
 478
 479         /*  may need to wait 72 sampling periods if timing was changed */
 480         i8254_load(dev->iobase + I8253_BASE_REG, 0, 2, 72, 0);
 481
 482         /*  setup start triggering */
 483         trigger_bits = 0;
 484         /*  decide if we need to wait 72 periods for valid data */
 485         if (cmd->start_src == TRIG_NOW &&
 486             (old_config_bits & CLOCK_MASK) !=
 487             (devpriv->config_bits & CLOCK_MASK)) {
 488                 /*  set trigger source to delay trigger */
 489                 trigger_bits |= DELAY_TRIGGER_BITS;
 490         } else {
 491                 /*  otherwise no delay */
 492                 trigger_bits |= POST_TRIGGER_BITS;
 493         }
 494         /*  enable external hardware trigger */
 495         if (cmd->start_src == TRIG_EXT) {
 496                 trigger_bits |= HW_TRIG_EN;
 497         } else if (cmd->start_src == TRIG_OTHER) {
 498                 /*  XXX add support for level/slope start trigger using TRIG_OTHER */
 499                 comedi_error(dev, "you shouldn't see this?");
 500         }
 501         /*  send trigger config bits */
 502         outw(trigger_bits, dev->iobase + TRIGGER_REG);
 503
 504         /*  start acquisition for soft trigger */
 505         if (cmd->start_src == TRIG_NOW)
 506                 outw(0, dev->iobase + FIFO_START_REG);
 507 #ifdef A2150_DEBUG
 508         ni_dump_regs(dev);
 509 #endif
 510
 511         return 0;
 512 }
 513
 514 static int a2150_ai_rinsn(struct comedi_device *dev, struct comedi_subdevice *s,
 515                           struct comedi_insn *insn, unsigned int *data)
 516 {
 517         struct a2150_private *devpriv = dev->private;
 518         unsigned int i, n;
 519         static const int timeout = 100000;
 520         static const int filter_delay = 36;
 521
 522         /*  clear fifo and reset triggering circuitry */
 523         outw(0, dev->iobase + FIFO_RESET_REG);
 524
 525         /* setup chanlist */
 526         if (a2150_set_chanlist(dev, CR_CHAN(insn->chanspec), 1) < 0)
 527                 return -1;
 528
 529         /*  set dc coupling */
 530         devpriv->config_bits &= ~AC0_BIT;
 531         devpriv->config_bits &= ~AC1_BIT;
 532
 533         /*  send timing, channel, config bits */
 534         outw(devpriv->config_bits, dev->iobase + CONFIG_REG);
 535
 536         /*  disable dma on card */
 537         devpriv->irq_dma_bits &= ~DMA_INTR_EN_BIT & ~DMA_EN_BIT;
 538         outw(devpriv->irq_dma_bits, dev->iobase + IRQ_DMA_CNTRL_REG);
 539
 540         /*  setup start triggering */
 541         outw(0, dev->iobase + TRIGGER_REG);
 542
 543         /*  start acquisition for soft trigger */
 544         outw(0, dev->iobase + FIFO_START_REG);
 545
 546         /*
 547          * there is a 35.6 sample delay for data to get through the
 548          * antialias filter
 549          */
 550         for (n = 0; n < filter_delay; n++) {
 551                 for (i = 0; i < timeout; i++) {
 552                         if (inw(dev->iobase + STATUS_REG) & FNE_BIT)
 553                                 break;
 554                         udelay(1);
 555                 }
 556                 if (i == timeout) {
 557                         comedi_error(dev, "timeout");
 558                         return -ETIME;
 559                 }
 560                 inw(dev->iobase + FIFO_DATA_REG);
 561         }
 562
 563         /*  read data */
 564         for (n = 0; n < insn->n; n++) {
 565                 for (i = 0; i < timeout; i++) {
 566                         if (inw(dev->iobase + STATUS_REG) & FNE_BIT)
 567                                 break;
 568                         udelay(1);
 569                 }
 570                 if (i == timeout) {
 571                         comedi_error(dev, "timeout");
 572                         return -ETIME;
 573                 }
 574 #ifdef A2150_DEBUG
 575                 ni_dump_regs(dev);
 576 #endif
 577                 data[n] = inw(dev->iobase + FIFO_DATA_REG);
 578 #ifdef A2150_DEBUG
 579                 printk(" data is %i\n", data[n]);
 580 #endif
 581                 data[n] ^= 0x8000;
 582         }
 583
 584         /*  clear fifo and reset triggering circuitry */
 585         outw(0, dev->iobase + FIFO_RESET_REG);
 586
 587         return n;
 588 }
 589
 590 /*
 591  * sets bits in devpriv->clock_bits to nearest approximation of requested
 592  * period, adjusts requested period to actual timing.
 593  */
 594 static int a2150_get_timing(struct comedi_device *dev, unsigned int *period,
 595                             int flags)
 596 {
 597         const struct a2150_board *thisboard = comedi_board(dev);
 598         struct a2150_private *devpriv = dev->private;
 599         int lub, glb, temp;
 600         int lub_divisor_shift, lub_index, glb_divisor_shift, glb_index;
 601         int i, j;
 602
 603         /*  initialize greatest lower and least upper bounds */
 604         lub_divisor_shift = 3;
 605         lub_index = 0;
 606         lub = thisboard->clock[lub_index] * (1 << lub_divisor_shift);
 607         glb_divisor_shift = 0;
 608         glb_index = thisboard->num_clocks - 1;
 609         glb = thisboard->clock[glb_index] * (1 << glb_divisor_shift);
 610
 611         /*  make sure period is in available range */
 612         if (*period < glb)
 613                 *period = glb;
 614         if (*period > lub)
 615                 *period = lub;
 616
 617         /*  we can multiply period by 1, 2, 4, or 8, using (1 << i) */
 618         for (i = 0; i < 4; i++) {
 619                 /*  there are a maximum of 4 master clocks */
 620                 for (j = 0; j < thisboard->num_clocks; j++) {
 621                         /*  temp is the period in nanosec we are evaluating */
 622                         temp = thisboard->clock[j] * (1 << i);
 623                         /*  if it is the best match yet */
 624                         if (temp < lub && temp >= *period) {
 625                                 lub_divisor_shift = i;
 626                                 lub_index = j;
 627                                 lub = temp;
 628                         }
 629                         if (temp > glb && temp <= *period) {
 630                                 glb_divisor_shift = i;
 631                                 glb_index = j;
 632                                 glb = temp;
 633                         }
 634                 }
 635         }
 636         flags &= TRIG_ROUND_MASK;
 637         switch (flags) {
 638         case TRIG_ROUND_NEAREST:
 639         default:
 640                 /*  if least upper bound is better approximation */
 641                 if (lub - *period < *period - glb)
 642                         *period = lub;
 643                 else
 644                         *period = glb;
 645                 break;
 646         case TRIG_ROUND_UP:
 647                 *period = lub;
 648                 break;
 649         case TRIG_ROUND_DOWN:
 650                 *period = glb;
 651                 break;
 652         }
 653
 654         /*  set clock bits for config register appropriately */
 655         devpriv->config_bits &= ~CLOCK_MASK;
 656         if (*period == lub) {
 657                 devpriv->config_bits |=
 658                     CLOCK_SELECT_BITS(lub_index) |
 659                     CLOCK_DIVISOR_BITS(lub_divisor_shift);
 660         } else {
 661                 devpriv->config_bits |=
 662                     CLOCK_SELECT_BITS(glb_index) |
 663                     CLOCK_DIVISOR_BITS(glb_divisor_shift);
 664         }
 665
 666         return 0;
 667 }
 668
 669 static int a2150_set_chanlist(struct comedi_device *dev,
 670                               unsigned int start_channel,
 671                               unsigned int num_channels)
 672 {
 673         struct a2150_private *devpriv = dev->private;
 674
 675         if (start_channel + num_channels > 4)
 676                 return -1;
 677
 678         devpriv->config_bits &= ~CHANNEL_MASK;
 679
 680         switch (num_channels) {
 681         case 1:
 682                 devpriv->config_bits |= CHANNEL_BITS(0x4 | start_channel);
 683                 break;
 684         case 2:
 685                 if (start_channel == 0) {
 686                         devpriv->config_bits |= CHANNEL_BITS(0x2);
 687                 } else if (start_channel == 2) {
 688                         devpriv->config_bits |= CHANNEL_BITS(0x3);
 689                 } else {
 690                         return -1;
 691                 }
 692                 break;
 693         case 4:
 694                 devpriv->config_bits |= CHANNEL_BITS(0x1);
 695                 break;
 696         default:
 697                 return -1;
 698                 break;
 699         }
 700
 701         return 0;
 702 }
 703
 704 /* probes board type, returns offset */
 705 static int a2150_probe(struct comedi_device *dev)
 706 {
 707         int status = inw(dev->iobase + STATUS_REG);
 708         return ID_BITS(status);
 709 }
 710
 711 static int a2150_attach(struct comedi_device *dev, struct comedi_devconfig *it)
 712 {
 713         const struct a2150_board *thisboard = comedi_board(dev);
 714         struct a2150_private *devpriv;
 715         struct comedi_subdevice *s;
 716         unsigned int irq = it->options[1];
 717         unsigned int dma = it->options[2];
 718         static const int timeout = 2000;
 719         int i;
 720         int ret;
 721
 722         devpriv = kzalloc(sizeof(*devpriv), GFP_KERNEL);
 723         if (!devpriv)
 724                 return -ENOMEM;
 725         dev->private = devpriv;
 726
 727         ret = comedi_request_region(dev, it->options[0], A2150_SIZE);
 728         if (ret)
 729                 return ret;
 730
 731         /* grab our IRQ */
 732         if (irq) {
 733                 /*  check that irq is supported */
 734                 if (irq < 3 || irq == 8 || irq == 13 || irq > 15) {
 735                         printk(" invalid irq line %u\n", irq);
 736                         return -EINVAL;
 737                 }
 738                 if (request_irq(irq, a2150_interrupt, 0,
 739                                 dev->driver->driver_name, dev)) {
 740                         printk("unable to allocate irq %u\n", irq);
 741                         return -EINVAL;
 742                 }
 743                 devpriv->irq_dma_bits |= IRQ_LVL_BITS(irq);
 744                 dev->irq = irq;
 745         }
 746         /*  initialize dma */
 747         if (dma) {
 748                 if (dma == 4 || dma > 7) {
 749                         printk(" invalid dma channel %u\n", dma);
 750                         return -EINVAL;
 751                 }
 752                 if (request_dma(dma, dev->driver->driver_name)) {
 753                         printk(" failed to allocate dma channel %u\n", dma);
 754                         return -EINVAL;
 755                 }
 756                 devpriv->dma = dma;
 757                 devpriv->dma_buffer =
 758                     kmalloc(A2150_DMA_BUFFER_SIZE, GFP_KERNEL | GFP_DMA);
 759                 if (devpriv->dma_buffer == NULL)
 760                         return -ENOMEM;
 761
 762                 disable_dma(dma);
 763                 set_dma_mode(dma, DMA_MODE_READ);
 764
 765                 devpriv->irq_dma_bits |= DMA_CHAN_BITS(dma);
 766         }
 767
 768         dev->board_ptr = a2150_boards + a2150_probe(dev);
 769         thisboard = comedi_board(dev);
 770         dev->board_name = thisboard->name;
 771
 772         ret = comedi_alloc_subdevices(dev, 1);
 773         if (ret)
 774                 return ret;
 775
 776         /* analog input subdevice */
 777         s = &dev->subdevices[0];
 778         dev->read_subdev = s;
 779         s->type = COMEDI_SUBD_AI;
 780         s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_OTHER | SDF_CMD_READ;
 781         s->n_chan = 4;
 782         s->len_chanlist = 4;
 783         s->maxdata = 0xffff;
 784         s->range_table = &range_a2150;
 785         s->do_cmd = a2150_ai_cmd;
 786         s->do_cmdtest = a2150_ai_cmdtest;
 787         s->insn_read = a2150_ai_rinsn;
 788         s->cancel = a2150_cancel;
 789
 790         /* need to do this for software counting of completed conversions, to
 791          * prevent hardware count from stopping acquisition */
 792         outw(HW_COUNT_DISABLE, dev->iobase + I8253_MODE_REG);
 793
 794         /*  set card's irq and dma levels */
 795         outw(devpriv->irq_dma_bits, dev->iobase + IRQ_DMA_CNTRL_REG);
 796
 797         /*  reset and sync adc clock circuitry */
 798         outw_p(DPD_BIT | APD_BIT, dev->iobase + CONFIG_REG);
 799         outw_p(DPD_BIT, dev->iobase + CONFIG_REG);
 800         /*  initialize configuration register */
 801         devpriv->config_bits = 0;
 802         outw(devpriv->config_bits, dev->iobase + CONFIG_REG);
 803         /*  wait until offset calibration is done, then enable analog inputs */
 804         for (i = 0; i < timeout; i++) {
 805                 if ((DCAL_BIT & inw(dev->iobase + STATUS_REG)) == 0)
 806                         break;
 807                 udelay(1000);
 808         }
 809         if (i == timeout) {
 810                 printk
 811                     (" timed out waiting for offset calibration to complete\n");
 812                 return -ETIME;
 813         }
 814         devpriv->config_bits |= ENABLE0_BIT | ENABLE1_BIT;
 815         outw(devpriv->config_bits, dev->iobase + CONFIG_REG);
 816
 817         return 0;
 818 };
 819
 820 static void a2150_detach(struct comedi_device *dev)
 821 {
 822         struct a2150_private *devpriv = dev->private;
 823
 824         if (dev->iobase)
 825                 outw(APD_BIT | DPD_BIT, dev->iobase + CONFIG_REG);
 826         if (devpriv) {
 827                 if (devpriv->dma)
 828                         free_dma(devpriv->dma);
 829                 kfree(devpriv->dma_buffer);
 830         }
 831         comedi_legacy_detach(dev);
 832 };
 833
 834 static struct comedi_driver ni_at_a2150_driver = {
 835         .driver_name    = "ni_at_a2150",
 836         .module         = THIS_MODULE,
 837         .attach         = a2150_attach,
 838         .detach         = a2150_detach,
 839 };
 840 module_comedi_driver(ni_at_a2150_driver);
 841
 842 MODULE_AUTHOR("Comedi http://www.comedi.org");
 843 MODULE_DESCRIPTION("Comedi low-level driver");
 844 MODULE_LICENSE("GPL");