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