Staging: comedi: pcmcia irq fixes
[linux-2.6.git] / 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