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