drivers/staging/comedi/drivers/quatech_daqp_cs.c

   1 /*======================================================================
   2
   3     comedi/drivers/quatech_daqp_cs.c
   4
   5     Quatech DAQP PCMCIA data capture cards COMEDI client driver
   6     Copyright (C) 2000, 2003 Brent Baccala <baccala@freesoft.org>
   7     The DAQP interface code in this file is released into the public domain.
   8
   9     COMEDI - Linux Control and Measurement Device Interface
  10     Copyright (C) 1998 David A. Schleef <ds@schleef.org>
  11     http://www.comedi.org/
  12
  13     quatech_daqp_cs.c 1.10
  14
  15     Documentation for the DAQP PCMCIA cards can be found on Quatech's site:
  16
  17                 ftp://ftp.quatech.com/Manuals/daqp-208.pdf
  18
  19     This manual is for both the DAQP-208 and the DAQP-308.
  20
  21     What works:
  22
  23         - A/D conversion
  24             - 8 channels
  25             - 4 gain ranges
  26             - ground ref or differential
  27             - single-shot and timed both supported
  28         - D/A conversion, single-shot
  29         - digital I/O
  30
  31     What doesn't:
  32
  33         - any kind of triggering - external or D/A channel 1
  34         - the card's optional expansion board
  35         - the card's timer (for anything other than A/D conversion)
  36         - D/A update modes other than immediate (i.e, timed)
  37         - fancier timing modes
  38         - setting card's FIFO buffer thresholds to anything but default
  39
  40 ======================================================================*/
  41
  42 /*
  43 Driver: quatech_daqp_cs
  44 Description: Quatech DAQP PCMCIA data capture cards
  45 Author: Brent Baccala <baccala@freesoft.org>
  46 Status: works
  47 Devices: [Quatech] DAQP-208 (daqp), DAQP-308
  48 */
  49
  50 #include "../comedidev.h"
  51 #include <linux/semaphore.h>
  52
  53 #include <pcmcia/cistpl.h>
  54 #include <pcmcia/cisreg.h>
  55 #include <pcmcia/ds.h>
  56
  57 #include <linux/completion.h>
  58
  59 #include "comedi_fc.h"
  60
  61 /* Maximum number of separate DAQP devices we'll allow */
  62 #define MAX_DEV         4
  63
  64 struct local_info_t {
  65         struct pcmcia_device *link;
  66         int stop;
  67         int table_index;
  68         char board_name[32];
  69
  70         enum { semaphore, buffer } interrupt_mode;
  71
  72         struct completion eos;
  73
  74         struct comedi_device *dev;
  75         struct comedi_subdevice *s;
  76         int count;
  77 };
  78
  79 /* A list of "instances" of the device. */
  80
  81 static struct local_info_t *dev_table[MAX_DEV] = { NULL, /* ... */  };
  82
  83 /* The DAQP communicates with the system through a 16 byte I/O window. */
  84
  85 #define DAQP_FIFO_SIZE          4096
  86
  87 #define DAQP_FIFO               0
  88 #define DAQP_SCANLIST           1
  89 #define DAQP_CONTROL            2
  90 #define DAQP_STATUS             2
  91 #define DAQP_DIGITAL_IO         3
  92 #define DAQP_PACER_LOW          4
  93 #define DAQP_PACER_MID          5
  94 #define DAQP_PACER_HIGH         6
  95 #define DAQP_COMMAND            7
  96 #define DAQP_DA                 8
  97 #define DAQP_TIMER              10
  98 #define DAQP_AUX                15
  99
 100 #define DAQP_SCANLIST_DIFFERENTIAL      0x4000
 101 #define DAQP_SCANLIST_GAIN(x)           ((x)<<12)
 102 #define DAQP_SCANLIST_CHANNEL(x)        ((x)<<8)
 103 #define DAQP_SCANLIST_START             0x0080
 104 #define DAQP_SCANLIST_EXT_GAIN(x)       ((x)<<4)
 105 #define DAQP_SCANLIST_EXT_CHANNEL(x)    (x)
 106
 107 #define DAQP_CONTROL_PACER_100kHz       0xc0
 108 #define DAQP_CONTROL_PACER_1MHz         0x80
 109 #define DAQP_CONTROL_PACER_5MHz         0x40
 110 #define DAQP_CONTROL_PACER_EXTERNAL     0x00
 111 #define DAQP_CONTORL_EXPANSION          0x20
 112 #define DAQP_CONTROL_EOS_INT_ENABLE     0x10
 113 #define DAQP_CONTROL_FIFO_INT_ENABLE    0x08
 114 #define DAQP_CONTROL_TRIGGER_ONESHOT    0x00
 115 #define DAQP_CONTROL_TRIGGER_CONTINUOUS 0x04
 116 #define DAQP_CONTROL_TRIGGER_INTERNAL   0x00
 117 #define DAQP_CONTROL_TRIGGER_EXTERNAL   0x02
 118 #define DAQP_CONTROL_TRIGGER_RISING     0x00
 119 #define DAQP_CONTROL_TRIGGER_FALLING    0x01
 120
 121 #define DAQP_STATUS_IDLE                0x80
 122 #define DAQP_STATUS_RUNNING             0x40
 123 #define DAQP_STATUS_EVENTS              0x38
 124 #define DAQP_STATUS_DATA_LOST           0x20
 125 #define DAQP_STATUS_END_OF_SCAN         0x10
 126 #define DAQP_STATUS_FIFO_THRESHOLD      0x08
 127 #define DAQP_STATUS_FIFO_FULL           0x04
 128 #define DAQP_STATUS_FIFO_NEARFULL       0x02
 129 #define DAQP_STATUS_FIFO_EMPTY          0x01
 130
 131 #define DAQP_COMMAND_ARM                0x80
 132 #define DAQP_COMMAND_RSTF               0x40
 133 #define DAQP_COMMAND_RSTQ               0x20
 134 #define DAQP_COMMAND_STOP               0x10
 135 #define DAQP_COMMAND_LATCH              0x08
 136 #define DAQP_COMMAND_100kHz             0x00
 137 #define DAQP_COMMAND_50kHz              0x02
 138 #define DAQP_COMMAND_25kHz              0x04
 139 #define DAQP_COMMAND_FIFO_DATA          0x01
 140 #define DAQP_COMMAND_FIFO_PROGRAM       0x00
 141
 142 #define DAQP_AUX_TRIGGER_TTL            0x00
 143 #define DAQP_AUX_TRIGGER_ANALOG         0x80
 144 #define DAQP_AUX_TRIGGER_PRETRIGGER     0x40
 145 #define DAQP_AUX_TIMER_INT_ENABLE       0x20
 146 #define DAQP_AUX_TIMER_RELOAD           0x00
 147 #define DAQP_AUX_TIMER_PAUSE            0x08
 148 #define DAQP_AUX_TIMER_GO               0x10
 149 #define DAQP_AUX_TIMER_GO_EXTERNAL      0x18
 150 #define DAQP_AUX_TIMER_EXTERNAL_SRC     0x04
 151 #define DAQP_AUX_TIMER_INTERNAL_SRC     0x00
 152 #define DAQP_AUX_DA_DIRECT              0x00
 153 #define DAQP_AUX_DA_OVERFLOW            0x01
 154 #define DAQP_AUX_DA_EXTERNAL            0x02
 155 #define DAQP_AUX_DA_PACER               0x03
 156
 157 #define DAQP_AUX_RUNNING                0x80
 158 #define DAQP_AUX_TRIGGERED              0x40
 159 #define DAQP_AUX_DA_BUFFER              0x20
 160 #define DAQP_AUX_TIMER_OVERFLOW         0x10
 161 #define DAQP_AUX_CONVERSION             0x08
 162 #define DAQP_AUX_DATA_LOST              0x04
 163 #define DAQP_AUX_FIFO_NEARFULL          0x02
 164 #define DAQP_AUX_FIFO_EMPTY             0x01
 165
 166 /* These range structures tell COMEDI how the sample values map to
 167  * voltages.  The A/D converter has four        .ranges = +/- 10V through
 168  * +/- 1.25V, and the D/A converter has only    .one = +/- 5V.
 169  */
 170
 171 static const struct comedi_lrange range_daqp_ai = { 4, {
 172                                                         BIP_RANGE(10),
 173                                                         BIP_RANGE(5),
 174                                                         BIP_RANGE(2.5),
 175                                                         BIP_RANGE(1.25)
 176                                                         }
 177 };
 178
 179 static const struct comedi_lrange range_daqp_ao = { 1, {BIP_RANGE(5)} };
 180
 181 /*====================================================================*/
 182
 183 /* comedi interface code */
 184
 185 static int daqp_attach(struct comedi_device *dev, struct comedi_devconfig *it);
 186 static void daqp_detach(struct comedi_device *dev);
 187 static struct comedi_driver driver_daqp = {
 188         .driver_name = "quatech_daqp_cs",
 189         .module = THIS_MODULE,
 190         .attach = daqp_attach,
 191         .detach = daqp_detach,
 192 };
 193
 194 #ifdef DAQP_DEBUG
 195
 196 static void daqp_dump(struct comedi_device *dev)
 197 {
 198         printk(KERN_INFO "DAQP: status %02x; aux status %02x\n",
 199                inb(dev->iobase + DAQP_STATUS), inb(dev->iobase + DAQP_AUX));
 200 }
 201
 202 static void hex_dump(char *str, void *ptr, int len)
 203 {
 204         unsigned char *cptr = ptr;
 205         int i;
 206
 207         printk(str);
 208
 209         for (i = 0; i < len; i++) {
 210                 if (i % 16 == 0)
 211                         printk("\n%p:", cptr);
 212
 213                 printk(" %02x", *(cptr++));
 214         }
 215         printk("\n");
 216 }
 217
 218 #endif
 219
 220 /* Cancel a running acquisition */
 221
 222 static int daqp_ai_cancel(struct comedi_device *dev, struct comedi_subdevice *s)
 223 {
 224         struct local_info_t *local = (struct local_info_t *)s->private;
 225
 226         if (local->stop)
 227                 return -EIO;
 228
 229
 230         outb(DAQP_COMMAND_STOP, dev->iobase + DAQP_COMMAND);
 231
 232         /* flush any linguring data in FIFO - superfluous here */
 233         /* outb(DAQP_COMMAND_RSTF, dev->iobase+DAQP_COMMAND); */
 234
 235         local->interrupt_mode = semaphore;
 236
 237         return 0;
 238 }
 239
 240 /* Interrupt handler
 241  *
 242  * Operates in one of two modes.  If local->interrupt_mode is
 243  * 'semaphore', just signal the local->eos completion and return
 244  * (one-shot mode).  Otherwise (continuous mode), read data in from
 245  * the card, transfer it to the buffer provided by the higher-level
 246  * comedi kernel module, and signal various comedi callback routines,
 247  * which run pretty quick.
 248  */
 249 static enum irqreturn daqp_interrupt(int irq, void *dev_id)
 250 {
 251         struct local_info_t *local = (struct local_info_t *)dev_id;
 252         struct comedi_device *dev;
 253         struct comedi_subdevice *s;
 254         int loop_limit = 10000;
 255         int status;
 256
 257         if (local == NULL) {
 258                 printk(KERN_WARNING
 259                        "daqp_interrupt(): irq %d for unknown device.\n", irq);
 260                 return IRQ_NONE;
 261         }
 262
 263         dev = local->dev;
 264         if (dev == NULL) {
 265                 printk(KERN_WARNING "daqp_interrupt(): NULL comedi_device.\n");
 266                 return IRQ_NONE;
 267         }
 268
 269         if (!dev->attached) {
 270                 printk(KERN_WARNING
 271                        "daqp_interrupt(): struct comedi_device not yet attached.\n");
 272                 return IRQ_NONE;
 273         }
 274
 275         s = local->s;
 276         if (s == NULL) {
 277                 printk(KERN_WARNING
 278                        "daqp_interrupt(): NULL comedi_subdevice.\n");
 279                 return IRQ_NONE;
 280         }
 281
 282         if ((struct local_info_t *)s->private != local) {
 283                 printk(KERN_WARNING
 284                        "daqp_interrupt(): invalid comedi_subdevice.\n");
 285                 return IRQ_NONE;
 286         }
 287
 288         switch (local->interrupt_mode) {
 289
 290         case semaphore:
 291
 292                 complete(&local->eos);
 293                 break;
 294
 295         case buffer:
 296
 297                 while (!((status = inb(dev->iobase + DAQP_STATUS))
 298                          & DAQP_STATUS_FIFO_EMPTY)) {
 299
 300                         short data;
 301
 302                         if (status & DAQP_STATUS_DATA_LOST) {
 303                                 s->async->events |=
 304                                     COMEDI_CB_EOA | COMEDI_CB_OVERFLOW;
 305                                 printk("daqp: data lost\n");
 306                                 daqp_ai_cancel(dev, s);
 307                                 break;
 308                         }
 309
 310                         data = inb(dev->iobase + DAQP_FIFO);
 311                         data |= inb(dev->iobase + DAQP_FIFO) << 8;
 312                         data ^= 0x8000;
 313
 314                         comedi_buf_put(s->async, data);
 315
 316                         /* If there's a limit, decrement it
 317                          * and stop conversion if zero
 318                          */
 319
 320                         if (local->count > 0) {
 321                                 local->count--;
 322                                 if (local->count == 0) {
 323                                         daqp_ai_cancel(dev, s);
 324                                         s->async->events |= COMEDI_CB_EOA;
 325                                         break;
 326                                 }
 327                         }
 328
 329                         if ((loop_limit--) <= 0)
 330                                 break;
 331                 }
 332
 333                 if (loop_limit <= 0) {
 334                         printk(KERN_WARNING
 335                                "loop_limit reached in daqp_interrupt()\n");
 336                         daqp_ai_cancel(dev, s);
 337                         s->async->events |= COMEDI_CB_EOA | COMEDI_CB_ERROR;
 338                 }
 339
 340                 s->async->events |= COMEDI_CB_BLOCK;
 341
 342                 comedi_event(dev, s);
 343         }
 344         return IRQ_HANDLED;
 345 }
 346
 347 /* One-shot analog data acquisition routine */
 348
 349 static int daqp_ai_insn_read(struct comedi_device *dev,
 350                              struct comedi_subdevice *s,
 351                              struct comedi_insn *insn, unsigned int *data)
 352 {
 353         struct local_info_t *local = (struct local_info_t *)s->private;
 354         int i;
 355         int v;
 356         int counter = 10000;
 357
 358         if (local->stop)
 359                 return -EIO;
 360
 361
 362         /* Stop any running conversion */
 363         daqp_ai_cancel(dev, s);
 364
 365         outb(0, dev->iobase + DAQP_AUX);
 366
 367         /* Reset scan list queue */
 368         outb(DAQP_COMMAND_RSTQ, dev->iobase + DAQP_COMMAND);
 369
 370         /* Program one scan list entry */
 371
 372         v = DAQP_SCANLIST_CHANNEL(CR_CHAN(insn->chanspec))
 373             | DAQP_SCANLIST_GAIN(CR_RANGE(insn->chanspec));
 374
 375         if (CR_AREF(insn->chanspec) == AREF_DIFF)
 376                 v |= DAQP_SCANLIST_DIFFERENTIAL;
 377
 378
 379         v |= DAQP_SCANLIST_START;
 380
 381         outb(v & 0xff, dev->iobase + DAQP_SCANLIST);
 382         outb(v >> 8, dev->iobase + DAQP_SCANLIST);
 383
 384         /* Reset data FIFO (see page 28 of DAQP User's Manual) */
 385
 386         outb(DAQP_COMMAND_RSTF, dev->iobase + DAQP_COMMAND);
 387
 388         /* Set trigger */
 389
 390         v = DAQP_CONTROL_TRIGGER_ONESHOT | DAQP_CONTROL_TRIGGER_INTERNAL
 391             | DAQP_CONTROL_PACER_100kHz | DAQP_CONTROL_EOS_INT_ENABLE;
 392
 393         outb(v, dev->iobase + DAQP_CONTROL);
 394
 395         /* Reset any pending interrupts (my card has a tendency to require
 396          * require multiple reads on the status register to achieve this)
 397          */
 398
 399         while (--counter
 400                && (inb(dev->iobase + DAQP_STATUS) & DAQP_STATUS_EVENTS)) ;
 401         if (!counter) {
 402                 printk("daqp: couldn't clear interrupts in status register\n");
 403                 return -1;
 404         }
 405
 406         init_completion(&local->eos);
 407         local->interrupt_mode = semaphore;
 408         local->dev = dev;
 409         local->s = s;
 410
 411         for (i = 0; i < insn->n; i++) {
 412
 413                 /* Start conversion */
 414                 outb(DAQP_COMMAND_ARM | DAQP_COMMAND_FIFO_DATA,
 415                      dev->iobase + DAQP_COMMAND);
 416
 417                 /* Wait for interrupt service routine to unblock completion */
 418                 /* Maybe could use a timeout here, but it's interruptible */
 419                 if (wait_for_completion_interruptible(&local->eos))
 420                         return -EINTR;
 421
 422                 data[i] = inb(dev->iobase + DAQP_FIFO);
 423                 data[i] |= inb(dev->iobase + DAQP_FIFO) << 8;
 424                 data[i] ^= 0x8000;
 425         }
 426
 427         return insn->n;
 428 }
 429
 430 /* This function converts ns nanoseconds to a counter value suitable
 431  * for programming the device.  We always use the DAQP's 5 MHz clock,
 432  * which with its 24-bit counter, allows values up to 84 seconds.
 433  * Also, the function adjusts ns so that it cooresponds to the actual
 434  * time that the device will use.
 435  */
 436
 437 static int daqp_ns_to_timer(unsigned int *ns, int round)
 438 {
 439         int timer;
 440
 441         timer = *ns / 200;
 442         *ns = timer * 200;
 443
 444         return timer;
 445 }
 446
 447 /* cmdtest tests a particular command to see if it is valid.
 448  * Using the cmdtest ioctl, a user can create a valid cmd
 449  * and then have it executed by the cmd ioctl.
 450  *
 451  * cmdtest returns 1,2,3,4 or 0, depending on which tests
 452  * the command passes.
 453  */
 454
 455 static int daqp_ai_cmdtest(struct comedi_device *dev,
 456                            struct comedi_subdevice *s, struct comedi_cmd *cmd)
 457 {
 458         int err = 0;
 459         int tmp;
 460
 461         /* Step 1 : check if triggers are trivially valid */
 462
 463         err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
 464         err |= cfc_check_trigger_src(&cmd->scan_begin_src,
 465                                         TRIG_TIMER | TRIG_FOLLOW);
 466         err |= cfc_check_trigger_src(&cmd->convert_src,
 467                                         TRIG_TIMER | TRIG_NOW);
 468         err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
 469         err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
 470
 471         if (err)
 472                 return 1;
 473
 474         /* Step 2a : make sure trigger sources are unique */
 475
 476         err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
 477         err |= cfc_check_trigger_is_unique(cmd->convert_src);
 478         err |= cfc_check_trigger_is_unique(cmd->stop_src);
 479
 480         /* Step 2b : and mutually compatible */
 481
 482         if (err)
 483                 return 2;
 484
 485         /* step 3: make sure arguments are trivially compatible */
 486
 487         if (cmd->start_arg != 0) {
 488                 cmd->start_arg = 0;
 489                 err++;
 490         }
 491 #define MAX_SPEED       10000   /* 100 kHz - in nanoseconds */
 492
 493         if (cmd->scan_begin_src == TRIG_TIMER
 494             && cmd->scan_begin_arg < MAX_SPEED) {
 495                 cmd->scan_begin_arg = MAX_SPEED;
 496                 err++;
 497         }
 498
 499         /* If both scan_begin and convert are both timer values, the only
 500          * way that can make sense is if the scan time is the number of
 501          * conversions times the convert time
 502          */
 503
 504         if (cmd->scan_begin_src == TRIG_TIMER && cmd->convert_src == TRIG_TIMER
 505             && cmd->scan_begin_arg != cmd->convert_arg * cmd->scan_end_arg) {
 506                 err++;
 507         }
 508
 509         if (cmd->convert_src == TRIG_TIMER && cmd->convert_arg < MAX_SPEED) {
 510                 cmd->convert_arg = MAX_SPEED;
 511                 err++;
 512         }
 513
 514         if (cmd->scan_end_arg != cmd->chanlist_len) {
 515                 cmd->scan_end_arg = cmd->chanlist_len;
 516                 err++;
 517         }
 518         if (cmd->stop_src == TRIG_COUNT) {
 519                 if (cmd->stop_arg > 0x00ffffff) {
 520                         cmd->stop_arg = 0x00ffffff;
 521                         err++;
 522                 }
 523         } else {
 524                 /* TRIG_NONE */
 525                 if (cmd->stop_arg != 0) {
 526                         cmd->stop_arg = 0;
 527                         err++;
 528                 }
 529         }
 530
 531         if (err)
 532                 return 3;
 533
 534         /* step 4: fix up any arguments */
 535
 536         if (cmd->scan_begin_src == TRIG_TIMER) {
 537                 tmp = cmd->scan_begin_arg;
 538                 daqp_ns_to_timer(&cmd->scan_begin_arg,
 539                                  cmd->flags & TRIG_ROUND_MASK);
 540                 if (tmp != cmd->scan_begin_arg)
 541                         err++;
 542         }
 543
 544         if (cmd->convert_src == TRIG_TIMER) {
 545                 tmp = cmd->convert_arg;
 546                 daqp_ns_to_timer(&cmd->convert_arg,
 547                                  cmd->flags & TRIG_ROUND_MASK);
 548                 if (tmp != cmd->convert_arg)
 549                         err++;
 550         }
 551
 552         if (err)
 553                 return 4;
 554
 555         return 0;
 556 }
 557
 558 static int daqp_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
 559 {
 560         struct local_info_t *local = (struct local_info_t *)s->private;
 561         struct comedi_cmd *cmd = &s->async->cmd;
 562         int counter;
 563         int scanlist_start_on_every_entry;
 564         int threshold;
 565
 566         int i;
 567         int v;
 568
 569         if (local->stop)
 570                 return -EIO;
 571
 572
 573         /* Stop any running conversion */
 574         daqp_ai_cancel(dev, s);
 575
 576         outb(0, dev->iobase + DAQP_AUX);
 577
 578         /* Reset scan list queue */
 579         outb(DAQP_COMMAND_RSTQ, dev->iobase + DAQP_COMMAND);
 580
 581         /* Program pacer clock
 582          *
 583          * There's two modes we can operate in.  If convert_src is
 584          * TRIG_TIMER, then convert_arg specifies the time between
 585          * each conversion, so we program the pacer clock to that
 586          * frequency and set the SCANLIST_START bit on every scanlist
 587          * entry.  Otherwise, convert_src is TRIG_NOW, which means
 588          * we want the fastest possible conversions, scan_begin_src
 589          * is TRIG_TIMER, and scan_begin_arg specifies the time between
 590          * each scan, so we program the pacer clock to this frequency
 591          * and only set the SCANLIST_START bit on the first entry.
 592          */
 593
 594         if (cmd->convert_src == TRIG_TIMER) {
 595                 counter = daqp_ns_to_timer(&cmd->convert_arg,
 596                                                cmd->flags & TRIG_ROUND_MASK);
 597                 outb(counter & 0xff, dev->iobase + DAQP_PACER_LOW);
 598                 outb((counter >> 8) & 0xff, dev->iobase + DAQP_PACER_MID);
 599                 outb((counter >> 16) & 0xff, dev->iobase + DAQP_PACER_HIGH);
 600                 scanlist_start_on_every_entry = 1;
 601         } else {
 602                 counter = daqp_ns_to_timer(&cmd->scan_begin_arg,
 603                                                cmd->flags & TRIG_ROUND_MASK);
 604                 outb(counter & 0xff, dev->iobase + DAQP_PACER_LOW);
 605                 outb((counter >> 8) & 0xff, dev->iobase + DAQP_PACER_MID);
 606                 outb((counter >> 16) & 0xff, dev->iobase + DAQP_PACER_HIGH);
 607                 scanlist_start_on_every_entry = 0;
 608         }
 609
 610         /* Program scan list */
 611
 612         for (i = 0; i < cmd->chanlist_len; i++) {
 613
 614                 int chanspec = cmd->chanlist[i];
 615
 616                 /* Program one scan list entry */
 617
 618                 v = DAQP_SCANLIST_CHANNEL(CR_CHAN(chanspec))
 619                     | DAQP_SCANLIST_GAIN(CR_RANGE(chanspec));
 620
 621                 if (CR_AREF(chanspec) == AREF_DIFF)
 622                         v |= DAQP_SCANLIST_DIFFERENTIAL;
 623
 624                 if (i == 0 || scanlist_start_on_every_entry)
 625                         v |= DAQP_SCANLIST_START;
 626
 627                 outb(v & 0xff, dev->iobase + DAQP_SCANLIST);
 628                 outb(v >> 8, dev->iobase + DAQP_SCANLIST);
 629         }
 630
 631         /* Now it's time to program the FIFO threshold, basically the
 632          * number of samples the card will buffer before it interrupts
 633          * the CPU.
 634          *
 635          * If we don't have a stop count, then use half the size of
 636          * the FIFO (the manufacturer's recommendation).  Consider
 637          * that the FIFO can hold 2K samples (4K bytes).  With the
 638          * threshold set at half the FIFO size, we have a margin of
 639          * error of 1024 samples.  At the chip's maximum sample rate
 640          * of 100,000 Hz, the CPU would have to delay interrupt
 641          * service for a full 10 milliseconds in order to lose data
 642          * here (as opposed to higher up in the kernel).  I've never
 643          * seen it happen.  However, for slow sample rates it may
 644          * buffer too much data and introduce too much delay for the
 645          * user application.
 646          *
 647          * If we have a stop count, then things get more interesting.
 648          * If the stop count is less than the FIFO size (actually
 649          * three-quarters of the FIFO size - see below), we just use
 650          * the stop count itself as the threshold, the card interrupts
 651          * us when that many samples have been taken, and we kill the
 652          * acquisition at that point and are done.  If the stop count
 653          * is larger than that, then we divide it by 2 until it's less
 654          * than three quarters of the FIFO size (we always leave the
 655          * top quarter of the FIFO as protection against sluggish CPU
 656          * interrupt response) and use that as the threshold.  So, if
 657          * the stop count is 4000 samples, we divide by two twice to
 658          * get 1000 samples, use that as the threshold, take four
 659          * interrupts to get our 4000 samples and are done.
 660          *
 661          * The algorithm could be more clever.  For example, if 81000
 662          * samples are requested, we could set the threshold to 1500
 663          * samples and take 54 interrupts to get 81000.  But 54 isn't
 664          * a power of two, so this algorithm won't find that option.
 665          * Instead, it'll set the threshold at 1266 and take 64
 666          * interrupts to get 81024 samples, of which the last 24 will
 667          * be discarded... but we won't get the last interrupt until
 668          * they've been collected.  To find the first option, the
 669          * computer could look at the prime decomposition of the
 670          * sample count (81000 = 3^4 * 5^3 * 2^3) and factor it into a
 671          * threshold (1500 = 3 * 5^3 * 2^2) and an interrupt count (54
 672          * = 3^3 * 2).  Hmmm... a one-line while loop or prime
 673          * decomposition of integers... I'll leave it the way it is.
 674          *
 675          * I'll also note a mini-race condition before ignoring it in
 676          * the code.  Let's say we're taking 4000 samples, as before.
 677          * After 1000 samples, we get an interrupt.  But before that
 678          * interrupt is completely serviced, another sample is taken
 679          * and loaded into the FIFO.  Since the interrupt handler
 680          * empties the FIFO before returning, it will read 1001 samples.
 681          * If that happens four times, we'll end up taking 4004 samples,
 682          * not 4000.  The interrupt handler will discard the extra four
 683          * samples (by halting the acquisition with four samples still
 684          * in the FIFO), but we will have to wait for them.
 685          *
 686          * In short, this code works pretty well, but for either of
 687          * the two reasons noted, might end up waiting for a few more
 688          * samples than actually requested.  Shouldn't make too much
 689          * of a difference.
 690          */
 691
 692         /* Save away the number of conversions we should perform, and
 693          * compute the FIFO threshold (in bytes, not samples - that's
 694          * why we multiple local->count by 2 = sizeof(sample))
 695          */
 696
 697         if (cmd->stop_src == TRIG_COUNT) {
 698                 local->count = cmd->stop_arg * cmd->scan_end_arg;
 699                 threshold = 2 * local->count;
 700                 while (threshold > DAQP_FIFO_SIZE * 3 / 4)
 701                         threshold /= 2;
 702         } else {
 703                 local->count = -1;
 704                 threshold = DAQP_FIFO_SIZE / 2;
 705         }
 706
 707         /* Reset data FIFO (see page 28 of DAQP User's Manual) */
 708
 709         outb(DAQP_COMMAND_RSTF, dev->iobase + DAQP_COMMAND);
 710
 711         /* Set FIFO threshold.  First two bytes are near-empty
 712          * threshold, which is unused; next two bytes are near-full
 713          * threshold.  We computed the number of bytes we want in the
 714          * FIFO when the interrupt is generated, what the card wants
 715          * is actually the number of available bytes left in the FIFO
 716          * when the interrupt is to happen.
 717          */
 718
 719         outb(0x00, dev->iobase + DAQP_FIFO);
 720         outb(0x00, dev->iobase + DAQP_FIFO);
 721
 722         outb((DAQP_FIFO_SIZE - threshold) & 0xff, dev->iobase + DAQP_FIFO);
 723         outb((DAQP_FIFO_SIZE - threshold) >> 8, dev->iobase + DAQP_FIFO);
 724
 725         /* Set trigger */
 726
 727         v = DAQP_CONTROL_TRIGGER_CONTINUOUS | DAQP_CONTROL_TRIGGER_INTERNAL
 728             | DAQP_CONTROL_PACER_5MHz | DAQP_CONTROL_FIFO_INT_ENABLE;
 729
 730         outb(v, dev->iobase + DAQP_CONTROL);
 731
 732         /* Reset any pending interrupts (my card has a tendency to require
 733          * require multiple reads on the status register to achieve this)
 734          */
 735         counter = 100;
 736         while (--counter
 737                && (inb(dev->iobase + DAQP_STATUS) & DAQP_STATUS_EVENTS)) ;
 738         if (!counter) {
 739                 printk(KERN_ERR
 740                        "daqp: couldn't clear interrupts in status register\n");
 741                 return -1;
 742         }
 743
 744         local->interrupt_mode = buffer;
 745         local->dev = dev;
 746         local->s = s;
 747
 748         /* Start conversion */
 749         outb(DAQP_COMMAND_ARM | DAQP_COMMAND_FIFO_DATA,
 750              dev->iobase + DAQP_COMMAND);
 751
 752         return 0;
 753 }
 754
 755 /* Single-shot analog output routine */
 756
 757 static int daqp_ao_insn_write(struct comedi_device *dev,
 758                               struct comedi_subdevice *s,
 759                               struct comedi_insn *insn, unsigned int *data)
 760 {
 761         struct local_info_t *local = (struct local_info_t *)s->private;
 762         int d;
 763         unsigned int chan;
 764
 765         if (local->stop)
 766                 return -EIO;
 767
 768         chan = CR_CHAN(insn->chanspec);
 769         d = data[0];
 770         d &= 0x0fff;
 771         d ^= 0x0800;            /* Flip the sign */
 772         d |= chan << 12;
 773
 774         /* Make sure D/A update mode is direct update */
 775         outb(0, dev->iobase + DAQP_AUX);
 776
 777         outw(d, dev->iobase + DAQP_DA);
 778
 779         return 1;
 780 }
 781
 782 /* Digital input routine */
 783
 784 static int daqp_di_insn_read(struct comedi_device *dev,
 785                              struct comedi_subdevice *s,
 786                              struct comedi_insn *insn, unsigned int *data)
 787 {
 788         struct local_info_t *local = (struct local_info_t *)s->private;
 789
 790         if (local->stop)
 791                 return -EIO;
 792
 793         data[0] = inb(dev->iobase + DAQP_DIGITAL_IO);
 794
 795         return 1;
 796 }
 797
 798 /* Digital output routine */
 799
 800 static int daqp_do_insn_write(struct comedi_device *dev,
 801                               struct comedi_subdevice *s,
 802                               struct comedi_insn *insn, unsigned int *data)
 803 {
 804         struct local_info_t *local = (struct local_info_t *)s->private;
 805
 806         if (local->stop)
 807                 return -EIO;
 808
 809         outw(data[0] & 0xf, dev->iobase + DAQP_DIGITAL_IO);
 810
 811         return 1;
 812 }
 813
 814 /* daqp_attach is called via comedi_config to attach a comedi device
 815  * to a /dev/comedi*.  Note that this is different from daqp_cs_attach()
 816  * which is called by the pcmcia subsystem to attach the PCMCIA card
 817  * when it is inserted.
 818  */
 819
 820 static int daqp_attach(struct comedi_device *dev, struct comedi_devconfig *it)
 821 {
 822         int ret;
 823         struct local_info_t *local = dev_table[it->options[0]];
 824         struct comedi_subdevice *s;
 825
 826         if (it->options[0] < 0 || it->options[0] >= MAX_DEV || !local) {
 827                 printk("comedi%d: No such daqp device %d\n",
 828                        dev->minor, it->options[0]);
 829                 return -EIO;
 830         }
 831
 832         /* Typically brittle code that I don't completely understand,
 833          * but "it works on my card".  The intent is to pull the model
 834          * number of the card out the PCMCIA CIS and stash it away as
 835          * the COMEDI board_name.  Looks like the third field in
 836          * CISTPL_VERS_1 (offset 2) holds what we're looking for.  If
 837          * it doesn't work, who cares, just leave it as "DAQP".
 838          */
 839
 840         strcpy(local->board_name, "DAQP");
 841         dev->board_name = local->board_name;
 842         if (local->link->prod_id[2]) {
 843                 if (strncmp(local->link->prod_id[2], "DAQP", 4) == 0) {
 844                         strncpy(local->board_name, local->link->prod_id[2],
 845                                 sizeof(local->board_name));
 846                 }
 847         }
 848
 849         dev->iobase = local->link->resource[0]->start;
 850
 851         ret = comedi_alloc_subdevices(dev, 4);
 852         if (ret)
 853                 return ret;
 854
 855         printk(KERN_INFO "comedi%d: attaching daqp%d (io 0x%04lx)\n",
 856                dev->minor, it->options[0], dev->iobase);
 857
 858         s = &dev->subdevices[0];
 859         dev->read_subdev = s;
 860         s->private = local;
 861         s->type = COMEDI_SUBD_AI;
 862         s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_DIFF | SDF_CMD_READ;
 863         s->n_chan = 8;
 864         s->len_chanlist = 2048;
 865         s->maxdata = 0xffff;
 866         s->range_table = &range_daqp_ai;
 867         s->insn_read = daqp_ai_insn_read;
 868         s->do_cmdtest = daqp_ai_cmdtest;
 869         s->do_cmd = daqp_ai_cmd;
 870         s->cancel = daqp_ai_cancel;
 871
 872         s = &dev->subdevices[1];
 873         dev->write_subdev = s;
 874         s->private = local;
 875         s->type = COMEDI_SUBD_AO;
 876         s->subdev_flags = SDF_WRITEABLE;
 877         s->n_chan = 2;
 878         s->len_chanlist = 1;
 879         s->maxdata = 0x0fff;
 880         s->range_table = &range_daqp_ao;
 881         s->insn_write = daqp_ao_insn_write;
 882
 883         s = &dev->subdevices[2];
 884         s->private = local;
 885         s->type = COMEDI_SUBD_DI;
 886         s->subdev_flags = SDF_READABLE;
 887         s->n_chan = 1;
 888         s->len_chanlist = 1;
 889         s->insn_read = daqp_di_insn_read;
 890
 891         s = &dev->subdevices[3];
 892         s->private = local;
 893         s->type = COMEDI_SUBD_DO;
 894         s->subdev_flags = SDF_WRITEABLE;
 895         s->n_chan = 1;
 896         s->len_chanlist = 1;
 897         s->insn_write = daqp_do_insn_write;
 898
 899         return 1;
 900 }
 901
 902 static void daqp_detach(struct comedi_device *dev)
 903 {
 904         /* Nothing to cleanup */
 905 }
 906
 907 /*====================================================================
 908
 909     PCMCIA interface code
 910
 911     The rest of the code in this file is based on dummy_cs.c v1.24
 912     from the Linux pcmcia_cs distribution v3.1.8 and is subject
 913     to the following license agreement.
 914
 915     The remaining contents of this file are subject to the Mozilla Public
 916     License Version 1.1 (the "License"); you may not use this file
 917     except in compliance with the License. You may obtain a copy of
 918     the License at http://www.mozilla.org/MPL/
 919
 920     Software distributed under the License is distributed on an "AS
 921     IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 922     implied. See the License for the specific language governing
 923     rights and limitations under the License.
 924
 925     The initial developer of the original code is David A. Hinds
 926     <dhinds@pcmcia.sourceforge.org>.  Portions created by David A. Hinds
 927     are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
 928
 929     Alternatively, the contents of this file may be used under the
 930     terms of the GNU Public License version 2 (the "GPL"), in which
 931     case the provisions of the GPL are applicable instead of the
 932     above.  If you wish to allow the use of your version of this file
 933     only under the terms of the GPL and not to allow others to use
 934     your version of this file under the MPL, indicate your decision
 935     by deleting the provisions above and replace them with the notice
 936     and other provisions required by the GPL.  If you do not delete
 937     the provisions above, a recipient may use your version of this
 938     file under either the MPL or the GPL.
 939
 940 ======================================================================*/
 941
 942 static void daqp_cs_config(struct pcmcia_device *link);
 943 static void daqp_cs_release(struct pcmcia_device *link);
 944 static int daqp_cs_suspend(struct pcmcia_device *p_dev);
 945 static int daqp_cs_resume(struct pcmcia_device *p_dev);
 946
 947 static int daqp_cs_attach(struct pcmcia_device *);
 948 static void daqp_cs_detach(struct pcmcia_device *);
 949
 950 static int daqp_cs_attach(struct pcmcia_device *link)
 951 {
 952         struct local_info_t *local;
 953         int i;
 954
 955         dev_dbg(&link->dev, "daqp_cs_attach()\n");
 956
 957         for (i = 0; i < MAX_DEV; i++)
 958                 if (dev_table[i] == NULL)
 959                         break;
 960         if (i == MAX_DEV) {
 961                 printk(KERN_NOTICE "daqp_cs: no devices available\n");
 962                 return -ENODEV;
 963         }
 964
 965         /* Allocate space for private device-specific data */
 966         local = kzalloc(sizeof(struct local_info_t), GFP_KERNEL);
 967         if (!local)
 968                 return -ENOMEM;
 969
 970         local->table_index = i;
 971         dev_table[i] = local;
 972         local->link = link;
 973         link->priv = local;
 974
 975         daqp_cs_config(link);
 976
 977         return 0;
 978 }                               /* daqp_cs_attach */
 979
 980 static void daqp_cs_detach(struct pcmcia_device *link)
 981 {
 982         struct local_info_t *dev = link->priv;
 983
 984         dev->stop = 1;
 985         daqp_cs_release(link);
 986
 987         /* Unlink device structure, and free it */
 988         dev_table[dev->table_index] = NULL;
 989         kfree(dev);
 990
 991 }
 992
 993 static int daqp_pcmcia_config_loop(struct pcmcia_device *p_dev, void *priv_data)
 994 {
 995         if (p_dev->config_index == 0)
 996                 return -EINVAL;
 997
 998         return pcmcia_request_io(p_dev);
 999 }
1000
1001 static void daqp_cs_config(struct pcmcia_device *link)
1002 {
1003         int ret;
1004
1005         dev_dbg(&link->dev, "daqp_cs_config\n");
1006
1007         link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
1008
1009         ret = pcmcia_loop_config(link, daqp_pcmcia_config_loop, NULL);
1010         if (ret) {
1011                 dev_warn(&link->dev, "no configuration found\n");
1012                 goto failed;
1013         }
1014
1015         ret = pcmcia_request_irq(link, daqp_interrupt);
1016         if (ret)
1017                 goto failed;
1018
1019         ret = pcmcia_enable_device(link);
1020         if (ret)
1021                 goto failed;
1022
1023         return;
1024
1025 failed:
1026         daqp_cs_release(link);
1027
1028 }                               /* daqp_cs_config */
1029
1030 static void daqp_cs_release(struct pcmcia_device *link)
1031 {
1032         dev_dbg(&link->dev, "daqp_cs_release\n");
1033
1034         pcmcia_disable_device(link);
1035 }                               /* daqp_cs_release */
1036
1037 static int daqp_cs_suspend(struct pcmcia_device *link)
1038 {
1039         struct local_info_t *local = link->priv;
1040
1041         /* Mark the device as stopped, to block IO until later */
1042         local->stop = 1;
1043         return 0;
1044 }
1045
1046 static int daqp_cs_resume(struct pcmcia_device *link)
1047 {
1048         struct local_info_t *local = link->priv;
1049
1050         local->stop = 0;
1051
1052         return 0;
1053 }
1054
1055 /*====================================================================*/
1056
1057 #ifdef MODULE
1058
1059 static const struct pcmcia_device_id daqp_cs_id_table[] = {
1060         PCMCIA_DEVICE_MANF_CARD(0x0137, 0x0027),
1061         PCMCIA_DEVICE_NULL
1062 };
1063
1064 MODULE_DEVICE_TABLE(pcmcia, daqp_cs_id_table);
1065 MODULE_AUTHOR("Brent Baccala <baccala@freesoft.org>");
1066 MODULE_DESCRIPTION("Comedi driver for Quatech DAQP PCMCIA data capture cards");
1067 MODULE_LICENSE("GPL");
1068
1069 static struct pcmcia_driver daqp_cs_driver = {
1070         .probe = daqp_cs_attach,
1071         .remove = daqp_cs_detach,
1072         .suspend = daqp_cs_suspend,
1073         .resume = daqp_cs_resume,
1074         .id_table = daqp_cs_id_table,
1075         .owner = THIS_MODULE,
1076         .name = "quatech_daqp_cs",
1077 };
1078
1079 int __init init_module(void)
1080 {
1081         pcmcia_register_driver(&daqp_cs_driver);
1082         comedi_driver_register(&driver_daqp);
1083         return 0;
1084 }
1085
1086 void __exit cleanup_module(void)
1087 {
1088         comedi_driver_unregister(&driver_daqp);
1089         pcmcia_unregister_driver(&daqp_cs_driver);
1090 }
1091
1092 #endif