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