Staging: comedi: remove assignment in conditionals
[safe/jmp/linux-2.6] / 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, struct comedi_subdevice *s,
365         struct comedi_insn *insn, unsigned int *data)
366 {
367         struct local_info_t *local = (struct local_info_t *) s->private;
368         int i;
369         int v;
370         int counter = 10000;
371
372         if (local->stop) {
373                 return -EIO;
374         }
375
376         /* Stop any running conversion */
377         daqp_ai_cancel(dev, s);
378
379         outb(0, dev->iobase + DAQP_AUX);
380
381         /* Reset scan list queue */
382         outb(DAQP_COMMAND_RSTQ, dev->iobase + DAQP_COMMAND);
383
384         /* Program one scan list entry */
385
386         v = DAQP_SCANLIST_CHANNEL(CR_CHAN(insn->chanspec))
387                 | DAQP_SCANLIST_GAIN(CR_RANGE(insn->chanspec));
388
389         if (CR_AREF(insn->chanspec) == AREF_DIFF) {
390                 v |= DAQP_SCANLIST_DIFFERENTIAL;
391         }
392
393         v |= DAQP_SCANLIST_START;
394
395         outb(v & 0xff, dev->iobase + DAQP_SCANLIST);
396         outb(v >> 8, dev->iobase + DAQP_SCANLIST);
397
398         /* Reset data FIFO (see page 28 of DAQP User's Manual) */
399
400         outb(DAQP_COMMAND_RSTF, dev->iobase + DAQP_COMMAND);
401
402         /* Set trigger */
403
404         v = DAQP_CONTROL_TRIGGER_ONESHOT | DAQP_CONTROL_TRIGGER_INTERNAL
405                 | DAQP_CONTROL_PACER_100kHz | DAQP_CONTROL_EOS_INT_ENABLE;
406
407         outb(v, dev->iobase + DAQP_CONTROL);
408
409         /* Reset any pending interrupts (my card has a tendancy to require
410          * require multiple reads on the status register to achieve this)
411          */
412
413         while (--counter
414                 && (inb(dev->iobase + DAQP_STATUS) & DAQP_STATUS_EVENTS)) ;
415         if (!counter) {
416                 printk("daqp: couldn't clear interrupts in status register\n");
417                 return -1;
418         }
419
420         /* Make sure semaphore is blocked */
421         sema_init(&local->eos, 0);
422         local->interrupt_mode = semaphore;
423         local->dev = dev;
424         local->s = s;
425
426         for (i = 0; i < insn->n; i++) {
427
428                 /* Start conversion */
429                 outb(DAQP_COMMAND_ARM | DAQP_COMMAND_FIFO_DATA,
430                         dev->iobase + DAQP_COMMAND);
431
432                 /* Wait for interrupt service routine to unblock semaphore */
433                 /* Maybe could use a timeout here, but it's interruptible */
434                 if (down_interruptible(&local->eos))
435                         return -EINTR;
436
437                 data[i] = inb(dev->iobase + DAQP_FIFO);
438                 data[i] |= inb(dev->iobase + DAQP_FIFO) << 8;
439                 data[i] ^= 0x8000;
440         }
441
442         return insn->n;
443 }
444
445 /* This function converts ns nanoseconds to a counter value suitable
446  * for programming the device.  We always use the DAQP's 5 MHz clock,
447  * which with its 24-bit counter, allows values up to 84 seconds.
448  * Also, the function adjusts ns so that it cooresponds to the actual
449  * time that the device will use.
450  */
451
452 static int daqp_ns_to_timer(unsigned int *ns, int round)
453 {
454         int timer;
455
456         timer = *ns / 200;
457         *ns = timer * 200;
458
459         return timer;
460 }
461
462 /* cmdtest tests a particular command to see if it is valid.
463  * Using the cmdtest ioctl, a user can create a valid cmd
464  * and then have it executed by the cmd ioctl.
465  *
466  * cmdtest returns 1,2,3,4 or 0, depending on which tests
467  * the command passes.
468  */
469
470 static int daqp_ai_cmdtest(struct comedi_device *dev, struct comedi_subdevice *s,
471         struct comedi_cmd *cmd)
472 {
473         int err = 0;
474         int tmp;
475
476         /* step 1: make sure trigger sources are trivially valid */
477
478         tmp = cmd->start_src;
479         cmd->start_src &= TRIG_NOW;
480         if (!cmd->start_src || tmp != cmd->start_src)
481                 err++;
482
483         tmp = cmd->scan_begin_src;
484         cmd->scan_begin_src &= TRIG_TIMER | TRIG_FOLLOW;
485         if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
486                 err++;
487
488         tmp = cmd->convert_src;
489         cmd->convert_src &= TRIG_TIMER | TRIG_NOW;
490         if (!cmd->convert_src || tmp != cmd->convert_src)
491                 err++;
492
493         tmp = cmd->scan_end_src;
494         cmd->scan_end_src &= TRIG_COUNT;
495         if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
496                 err++;
497
498         tmp = cmd->stop_src;
499         cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
500         if (!cmd->stop_src || tmp != cmd->stop_src)
501                 err++;
502
503         if (err)
504                 return 1;
505
506         /* step 2: make sure trigger sources are unique and mutually compatible */
507
508         /* note that mutual compatiblity is not an issue here */
509         if (cmd->scan_begin_src != TRIG_TIMER &&
510                 cmd->scan_begin_src != TRIG_FOLLOW)
511                 err++;
512         if (cmd->convert_src != TRIG_NOW && cmd->convert_src != TRIG_TIMER)
513                 err++;
514         if (cmd->scan_begin_src == TRIG_FOLLOW && cmd->convert_src == TRIG_NOW)
515                 err++;
516         if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE)
517                 err++;
518
519         if (err)
520                 return 2;
521
522         /* step 3: make sure arguments are trivially compatible */
523
524         if (cmd->start_arg != 0) {
525                 cmd->start_arg = 0;
526                 err++;
527         }
528 #define MAX_SPEED       10000   /* 100 kHz - in nanoseconds */
529
530         if (cmd->scan_begin_src == TRIG_TIMER
531                 && cmd->scan_begin_arg < MAX_SPEED) {
532                 cmd->scan_begin_arg = MAX_SPEED;
533                 err++;
534         }
535
536         /* If both scan_begin and convert are both timer values, the only
537          * way that can make sense is if the scan time is the number of
538          * conversions times the convert time
539          */
540
541         if (cmd->scan_begin_src == TRIG_TIMER && cmd->convert_src == TRIG_TIMER
542                 && cmd->scan_begin_arg !=
543                 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, struct comedi_subdevice *s,
797         struct comedi_insn *insn, unsigned int *data)
798 {
799         struct local_info_t *local = (struct local_info_t *) s->private;
800         int d;
801         unsigned int chan;
802
803         if (local->stop) {
804                 return -EIO;
805         }
806
807         chan = CR_CHAN(insn->chanspec);
808         d = data[0];
809         d &= 0x0fff;
810         d ^= 0x0800;            /* Flip the sign */
811         d |= chan << 12;
812
813         /* Make sure D/A update mode is direct update */
814         outb(0, dev->iobase + DAQP_AUX);
815
816         outw(d, dev->iobase + DAQP_DA);
817
818         return 1;
819 }
820
821 /* Digital input routine */
822
823 static int daqp_di_insn_read(struct comedi_device *dev, struct comedi_subdevice *s,
824         struct comedi_insn *insn, unsigned int *data)
825 {
826         struct local_info_t *local = (struct local_info_t *) s->private;
827
828         if (local->stop) {
829                 return -EIO;
830         }
831
832         data[0] = inb(dev->iobase + DAQP_DIGITAL_IO);
833
834         return 1;
835 }
836
837 /* Digital output routine */
838
839 static int daqp_do_insn_write(struct comedi_device *dev, struct comedi_subdevice *s,
840         struct comedi_insn *insn, unsigned int *data)
841 {
842         struct local_info_t *local = (struct local_info_t *) s->private;
843
844         if (local->stop) {
845                 return -EIO;
846         }
847
848         outw(data[0] & 0xf, dev->iobase + DAQP_DIGITAL_IO);
849
850         return 1;
851 }
852
853 /* daqp_attach is called via comedi_config to attach a comedi device
854  * to a /dev/comedi*.  Note that this is different from daqp_cs_attach()
855  * which is called by the pcmcia subsystem to attach the PCMCIA card
856  * when it is inserted.
857  */
858
859 static int daqp_attach(struct comedi_device *dev, struct comedi_devconfig *it)
860 {
861         int ret;
862         struct local_info_t *local = dev_table[it->options[0]];
863         tuple_t tuple;
864         int i;
865         struct comedi_subdevice *s;
866
867         if (it->options[0] < 0 || it->options[0] >= MAX_DEV || !local) {
868                 printk("comedi%d: No such daqp device %d\n",
869                         dev->minor, it->options[0]);
870                 return -EIO;
871         }
872
873         /* Typically brittle code that I don't completely understand,
874          * but "it works on my card".  The intent is to pull the model
875          * number of the card out the PCMCIA CIS and stash it away as
876          * the COMEDI board_name.  Looks like the third field in
877          * CISTPL_VERS_1 (offset 2) holds what we're looking for.  If
878          * it doesn't work, who cares, just leave it as "DAQP".
879          */
880
881         strcpy(local->board_name, "DAQP");
882         dev->board_name = local->board_name;
883
884         tuple.DesiredTuple = CISTPL_VERS_1;
885         if (pcmcia_get_first_tuple(local->link, &tuple) == 0) {
886                 u_char buf[128];
887
888                 buf[0] = buf[sizeof(buf) - 1] = 0;
889                 tuple.TupleData = buf;
890                 tuple.TupleDataMax = sizeof(buf);
891                 tuple.TupleOffset = 2;
892                 if (pcmcia_get_tuple_data(local->link, &tuple) == 0) {
893
894                         for (i = 0; i < tuple.TupleDataLen - 4; i++)
895                                 if (buf[i] == 0)
896                                         break;
897                         for (i++; i < tuple.TupleDataLen - 4; i++)
898                                 if (buf[i] == 0)
899                                         break;
900                         i++;
901                         if ((i < tuple.TupleDataLen - 4)
902                                 && (strncmp(buf + i, "DAQP", 4) == 0)) {
903                                 strncpy(local->board_name, buf + i,
904                                         sizeof(local->board_name));
905                         }
906                 }
907         }
908
909         dev->iobase = local->link->io.BasePort1;
910
911         ret = alloc_subdevices(dev, 4);
912         if (ret < 0)
913                 return ret;
914
915         printk("comedi%d: attaching daqp%d (io 0x%04lx)\n",
916                 dev->minor, it->options[0], dev->iobase);
917
918         s = dev->subdevices + 0;
919         dev->read_subdev = s;
920         s->private = local;
921         s->type = COMEDI_SUBD_AI;
922         s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_DIFF | SDF_CMD_READ;
923         s->n_chan = 8;
924         s->len_chanlist = 2048;
925         s->maxdata = 0xffff;
926         s->range_table = &range_daqp_ai;
927         s->insn_read = daqp_ai_insn_read;
928         s->do_cmdtest = daqp_ai_cmdtest;
929         s->do_cmd = daqp_ai_cmd;
930         s->cancel = daqp_ai_cancel;
931
932         s = dev->subdevices + 1;
933         dev->write_subdev = s;
934         s->private = local;
935         s->type = COMEDI_SUBD_AO;
936         s->subdev_flags = SDF_WRITEABLE;
937         s->n_chan = 2;
938         s->len_chanlist = 1;
939         s->maxdata = 0x0fff;
940         s->range_table = &range_daqp_ao;
941         s->insn_write = daqp_ao_insn_write;
942
943         s = dev->subdevices + 2;
944         s->private = local;
945         s->type = COMEDI_SUBD_DI;
946         s->subdev_flags = SDF_READABLE;
947         s->n_chan = 1;
948         s->len_chanlist = 1;
949         s->insn_read = daqp_di_insn_read;
950
951         s = dev->subdevices + 3;
952         s->private = local;
953         s->type = COMEDI_SUBD_DO;
954         s->subdev_flags = SDF_WRITEABLE;
955         s->n_chan = 1;
956         s->len_chanlist = 1;
957         s->insn_write = daqp_do_insn_write;
958
959         return 1;
960 }
961
962 /* daqp_detach (called from comedi_comdig) does nothing. If the PCMCIA
963  * card is removed, daqp_cs_detach() is called by the pcmcia subsystem.
964  */
965
966 static int daqp_detach(struct comedi_device *dev)
967 {
968         printk("comedi%d: detaching daqp\n", dev->minor);
969
970         return 0;
971 }
972
973 /*====================================================================
974
975     PCMCIA interface code
976
977     The rest of the code in this file is based on dummy_cs.c v1.24
978     from the Linux pcmcia_cs distribution v3.1.8 and is subject
979     to the following license agreement.
980
981     The remaining contents of this file are subject to the Mozilla Public
982     License Version 1.1 (the "License"); you may not use this file
983     except in compliance with the License. You may obtain a copy of
984     the License at http://www.mozilla.org/MPL/
985
986     Software distributed under the License is distributed on an "AS
987     IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
988     implied. See the License for the specific language governing
989     rights and limitations under the License.
990
991     The initial developer of the original code is David A. Hinds
992     <dhinds@pcmcia.sourceforge.org>.  Portions created by David A. Hinds
993     are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
994
995     Alternatively, the contents of this file may be used under the
996     terms of the GNU Public License version 2 (the "GPL"), in which
997     case the provisions of the GPL are applicable instead of the
998     above.  If you wish to allow the use of your version of this file
999     only under the terms of the GPL and not to allow others to use
1000     your version of this file under the MPL, indicate your decision
1001     by deleting the provisions above and replace them with the notice
1002     and other provisions required by the GPL.  If you do not delete
1003     the provisions above, a recipient may use your version of this
1004     file under either the MPL or the GPL.
1005
1006 ======================================================================*/
1007
1008 /*
1009    The event() function is this driver's Card Services event handler.
1010    It will be called by Card Services when an appropriate card status
1011    event is received.  The config() and release() entry points are
1012    used to configure or release a socket, in response to card
1013    insertion and ejection events.
1014
1015    Kernel version 2.6.16 upwards uses suspend() and resume() functions
1016    instead of an event() function.
1017 */
1018
1019 static void daqp_cs_config(struct pcmcia_device *link);
1020 static void daqp_cs_release(struct pcmcia_device *link);
1021 static int daqp_cs_suspend(struct pcmcia_device *p_dev);
1022 static int daqp_cs_resume(struct pcmcia_device *p_dev);
1023
1024 /*
1025    The attach() and detach() entry points are used to create and destroy
1026    "instances" of the driver, where each instance represents everything
1027    needed to manage one actual PCMCIA card.
1028 */
1029
1030 static int daqp_cs_attach(struct pcmcia_device *);
1031 static void daqp_cs_detach(struct pcmcia_device *);
1032
1033 /*
1034    The dev_info variable is the "key" that is used to match up this
1035    device driver with appropriate cards, through the card configuration
1036    database.
1037 */
1038
1039 static const dev_info_t dev_info = "quatech_daqp_cs";
1040
1041 /*======================================================================
1042
1043     daqp_cs_attach() creates an "instance" of the driver, allocating
1044     local data structures for one device.  The device is registered
1045     with Card Services.
1046
1047     The dev_link structure is initialized, but we don't actually
1048     configure the card at this point -- we wait until we receive a
1049     card insertion event.
1050
1051 ======================================================================*/
1052
1053 static int daqp_cs_attach(struct pcmcia_device *link)
1054 {
1055         struct local_info_t *local;
1056         int i;
1057
1058         DEBUG(0, "daqp_cs_attach()\n");
1059
1060         for (i = 0; i < MAX_DEV; i++)
1061                 if (dev_table[i] == NULL)
1062                         break;
1063         if (i == MAX_DEV) {
1064                 printk(KERN_NOTICE "daqp_cs: no devices available\n");
1065                 return -ENODEV;
1066         }
1067
1068         /* Allocate space for private device-specific data */
1069         local = kzalloc(sizeof(struct local_info_t), GFP_KERNEL);
1070         if (!local)
1071                 return -ENOMEM;
1072
1073         local->table_index = i;
1074         dev_table[i] = local;
1075         local->link = link;
1076         link->priv = local;
1077
1078         /* Interrupt setup */
1079         link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
1080         link->irq.IRQInfo1 = IRQ_LEVEL_ID;
1081         link->irq.Handler = daqp_interrupt;
1082         link->irq.Instance = local;
1083
1084         /*
1085            General socket configuration defaults can go here.  In this
1086            client, we assume very little, and rely on the CIS for almost
1087            everything.  In most clients, many details (i.e., number, sizes,
1088            and attributes of IO windows) are fixed by the nature of the
1089            device, and can be hard-wired here.
1090          */
1091         link->conf.Attributes = 0;
1092         link->conf.IntType = INT_MEMORY_AND_IO;
1093
1094         daqp_cs_config(link);
1095
1096         return 0;
1097 }                               /* daqp_cs_attach */
1098
1099 /*======================================================================
1100
1101     This deletes a driver "instance".  The device is de-registered
1102     with Card Services.  If it has been released, all local data
1103     structures are freed.  Otherwise, the structures will be freed
1104     when the device is released.
1105
1106 ======================================================================*/
1107
1108 static void daqp_cs_detach(struct pcmcia_device *link)
1109 {
1110         struct local_info_t *dev = link->priv;
1111
1112         DEBUG(0, "daqp_cs_detach(0x%p)\n", link);
1113
1114         if (link->dev_node) {
1115                 dev->stop = 1;
1116                 daqp_cs_release(link);
1117         }
1118
1119         /* Unlink device structure, and free it */
1120         dev_table[dev->table_index] = NULL;
1121         if (dev)
1122                 kfree(dev);
1123
1124 }                               /* daqp_cs_detach */
1125
1126 /*======================================================================
1127
1128     daqp_cs_config() is scheduled to run after a CARD_INSERTION event
1129     is received, to configure the PCMCIA socket, and to make the
1130     device available to the system.
1131
1132 ======================================================================*/
1133
1134 static void daqp_cs_config(struct pcmcia_device *link)
1135 {
1136         struct local_info_t *dev = link->priv;
1137         tuple_t tuple;
1138         cisparse_t parse;
1139         int last_ret;
1140         u_char buf[64];
1141
1142         DEBUG(0, "daqp_cs_config(0x%p)\n", link);
1143
1144         /*
1145            This reads the card's CONFIG tuple to find its configuration
1146            registers.
1147          */
1148         tuple.DesiredTuple = CISTPL_CONFIG;
1149         tuple.Attributes = 0;
1150         tuple.TupleData = buf;
1151         tuple.TupleDataMax = sizeof(buf);
1152         tuple.TupleOffset = 0;
1153
1154         last_ret = pcmcia_get_first_tuple(link, &tuple);
1155         if (last_ret) {
1156                 cs_error(link, GetFirstTuple, last_ret);
1157                 goto cs_failed;
1158         }
1159
1160         last_ret = pcmcia_get_tuple_data(link, &tuple);
1161         if (last_ret) {
1162                 cs_error(link, GetTupleData, last_ret);
1163                 goto cs_failed;
1164         }
1165
1166         last_ret = pcmcia_parse_tuple(&tuple, &parse);
1167         if (last_ret) {
1168                 cs_error(link, ParseTuple, last_ret);
1169                 goto cs_failed;
1170         }
1171         link->conf.ConfigBase = parse.config.base;
1172         link->conf.Present = parse.config.rmask[0];
1173
1174         /*
1175            In this loop, we scan the CIS for configuration table entries,
1176            each of which describes a valid card configuration, including
1177            voltage, IO window, memory window, and interrupt settings.
1178
1179            We make no assumptions about the card to be configured: we use
1180            just the information available in the CIS.  In an ideal world,
1181            this would work for any PCMCIA card, but it requires a complete
1182            and accurate CIS.  In practice, a driver usually "knows" most of
1183            these things without consulting the CIS, and most client drivers
1184            will only use the CIS to fill in implementation-defined details.
1185          */
1186         tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
1187         last_ret = pcmcia_get_first_tuple(link, &tuple);
1188         if (last_ret) {
1189                 cs_error(link, GetFirstTuple, last_ret);
1190                 goto cs_failed;
1191         }
1192
1193         while (1) {
1194                 cistpl_cftable_entry_t dflt = { 0 };
1195                 cistpl_cftable_entry_t *cfg = &(parse.cftable_entry);
1196                 if (pcmcia_get_tuple_data(link, &tuple))
1197                         goto next_entry;
1198                 if (pcmcia_parse_tuple(&tuple, &parse))
1199                         goto next_entry;
1200
1201                 if (cfg->flags & CISTPL_CFTABLE_DEFAULT)
1202                         dflt = *cfg;
1203                 if (cfg->index == 0)
1204                         goto next_entry;
1205                 link->conf.ConfigIndex = cfg->index;
1206
1207                 /* Do we need to allocate an interrupt? */
1208                 if (cfg->irq.IRQInfo1 || dflt.irq.IRQInfo1)
1209                         link->conf.Attributes |= CONF_ENABLE_IRQ;
1210
1211                 /* IO window settings */
1212                 link->io.NumPorts1 = link->io.NumPorts2 = 0;
1213                 if ((cfg->io.nwin > 0) || (dflt.io.nwin > 0)) {
1214                         cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt.io;
1215                         link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
1216                         if (!(io->flags & CISTPL_IO_8BIT))
1217                                 link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
1218                         if (!(io->flags & CISTPL_IO_16BIT))
1219                                 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
1220                         link->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
1221                         link->io.BasePort1 = io->win[0].base;
1222                         link->io.NumPorts1 = io->win[0].len;
1223                         if (io->nwin > 1) {
1224                                 link->io.Attributes2 = link->io.Attributes1;
1225                                 link->io.BasePort2 = io->win[1].base;
1226                                 link->io.NumPorts2 = io->win[1].len;
1227                         }
1228                 }
1229
1230                 /* This reserves IO space but doesn't actually enable it */
1231                 if (pcmcia_request_io(link, &link->io))
1232                         goto next_entry;
1233
1234                 /* If we got this far, we're cool! */
1235                 break;
1236
1237               next_entry:
1238                 last_ret = pcmcia_get_next_tuple(link, &tuple);
1239                 if (last_ret) {
1240                         cs_error(link, GetNextTuple, last_ret);
1241                         goto cs_failed;
1242                 }
1243         }
1244
1245         /*
1246            Allocate an interrupt line.  Note that this does not assign a
1247            handler to the interrupt, unless the 'Handler' member of the
1248            irq structure is initialized.
1249          */
1250         if (link->conf.Attributes & CONF_ENABLE_IRQ) {
1251                 last_ret = pcmcia_request_irq(link, &link->irq);
1252                 if (last_ret) {
1253                         cs_error(link, RequestIRQ, last_ret);
1254                         goto cs_failed;
1255                 }
1256         }
1257
1258         /*
1259            This actually configures the PCMCIA socket -- setting up
1260            the I/O windows and the interrupt mapping, and putting the
1261            card and host interface into "Memory and IO" mode.
1262          */
1263         last_ret = pcmcia_request_configuration(link, &link->conf);
1264         if (last_ret) {
1265                 cs_error(link, RequestConfiguration, last_ret);
1266                 goto cs_failed;
1267         }
1268
1269         /*
1270            At this point, the dev_node_t structure(s) need to be
1271            initialized and arranged in a linked list at link->dev.
1272          */
1273         /* Comedi's PCMCIA script uses this device name (extracted
1274          * from /var/lib/pcmcia/stab) to pass to comedi_config
1275          */
1276         /* sprintf(dev->node.dev_name, "daqp%d", dev->table_index); */
1277         sprintf(dev->node.dev_name, "quatech_daqp_cs");
1278         dev->node.major = dev->node.minor = 0;
1279         link->dev_node = &dev->node;
1280
1281         /* Finally, report what we've done */
1282         printk(KERN_INFO "%s: index 0x%02x",
1283                 dev->node.dev_name, link->conf.ConfigIndex);
1284         if (link->conf.Attributes & CONF_ENABLE_IRQ)
1285                 printk(", irq %u", link->irq.AssignedIRQ);
1286         if (link->io.NumPorts1)
1287                 printk(", io 0x%04x-0x%04x", link->io.BasePort1,
1288                         link->io.BasePort1 + link->io.NumPorts1 - 1);
1289         if (link->io.NumPorts2)
1290                 printk(" & 0x%04x-0x%04x", link->io.BasePort2,
1291                         link->io.BasePort2 + link->io.NumPorts2 - 1);
1292         printk("\n");
1293
1294         return;
1295
1296       cs_failed:
1297         daqp_cs_release(link);
1298
1299 }                               /* daqp_cs_config */
1300
1301 static void daqp_cs_release(struct pcmcia_device *link)
1302 {
1303         DEBUG(0, "daqp_cs_release(0x%p)\n", link);
1304
1305         pcmcia_disable_device(link);
1306 }                               /* daqp_cs_release */
1307
1308 /*======================================================================
1309
1310     The card status event handler.  Mostly, this schedules other
1311     stuff to run after an event is received.
1312
1313     When a CARD_REMOVAL event is received, we immediately set a
1314     private flag to block future accesses to this device.  All the
1315     functions that actually access the device should check this flag
1316     to make sure the card is still present.
1317
1318 ======================================================================*/
1319
1320 static int daqp_cs_suspend(struct pcmcia_device *link)
1321 {
1322         struct local_info_t *local = link->priv;
1323
1324         /* Mark the device as stopped, to block IO until later */
1325         local->stop = 1;
1326         return 0;
1327 }
1328
1329 static int daqp_cs_resume(struct pcmcia_device *link)
1330 {
1331         struct local_info_t *local = link->priv;
1332
1333         local->stop = 0;
1334
1335         return 0;
1336 }
1337
1338 /*====================================================================*/
1339
1340 #ifdef MODULE
1341
1342 static struct pcmcia_device_id daqp_cs_id_table[] = {
1343         PCMCIA_DEVICE_MANF_CARD(0x0137, 0x0027),
1344         PCMCIA_DEVICE_NULL
1345 };
1346
1347 MODULE_DEVICE_TABLE(pcmcia, daqp_cs_id_table);
1348
1349 struct pcmcia_driver daqp_cs_driver = {
1350         .probe = daqp_cs_attach,
1351         .remove = daqp_cs_detach,
1352         .suspend = daqp_cs_suspend,
1353         .resume = daqp_cs_resume,
1354         .id_table = daqp_cs_id_table,
1355         .owner = THIS_MODULE,
1356         .drv = {
1357                         .name = dev_info,
1358                 },
1359 };
1360
1361 int __init init_module(void)
1362 {
1363         DEBUG(0, "%s\n", version);
1364         pcmcia_register_driver(&daqp_cs_driver);
1365         comedi_driver_register(&driver_daqp);
1366         return 0;
1367 }
1368
1369 void __exit cleanup_module(void)
1370 {
1371         DEBUG(0, "daqp_cs: unloading\n");
1372         comedi_driver_unregister(&driver_daqp);
1373         pcmcia_unregister_driver(&daqp_cs_driver);
1374 }
1375
1376 #endif