1 /*======================================================================
3 comedi/drivers/quatech_daqp_cs.c
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.
9 COMEDI - Linux Control and Measurement Device Interface
10 Copyright (C) 1998 David A. Schleef <ds@schleef.org>
11 http://www.comedi.org/
13 quatech_daqp_cs.c 1.10
15 Documentation for the DAQP PCMCIA cards can be found on Quatech's site:
17 ftp://ftp.quatech.com/Manuals/daqp-208.pdf
19 This manual is for both the DAQP-208 and the DAQP-308.
26 - ground ref or differential
27 - single-shot and timed both supported
28 - D/A conversion, single-shot
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
40 ======================================================================*/
43 Driver: quatech_daqp_cs
44 Description: Quatech DAQP PCMCIA data capture cards
45 Author: Brent Baccala <baccala@freesoft.org>
47 Devices: [Quatech] DAQP-208 (daqp), DAQP-308
50 #include "../comedidev.h"
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>
58 #include <linux/completion.h>
60 /* Maximum number of separate DAQP devices we'll allow */
64 struct pcmcia_device *link;
69 enum { semaphore, buffer } interrupt_mode;
71 struct completion eos;
73 struct comedi_device *dev;
74 struct comedi_subdevice *s;
78 /* A list of "instances" of the device. */
80 static struct local_info_t *dev_table[MAX_DEV] = { NULL, /* ... */ };
82 /* The DAQP communicates with the system through a 16 byte I/O window. */
84 #define DAQP_FIFO_SIZE 4096
87 #define DAQP_SCANLIST 1
88 #define DAQP_CONTROL 2
90 #define DAQP_DIGITAL_IO 3
91 #define DAQP_PACER_LOW 4
92 #define DAQP_PACER_MID 5
93 #define DAQP_PACER_HIGH 6
94 #define DAQP_COMMAND 7
99 #define DAQP_SCANLIST_DIFFERENTIAL 0x4000
100 #define DAQP_SCANLIST_GAIN(x) ((x)<<12)
101 #define DAQP_SCANLIST_CHANNEL(x) ((x)<<8)
102 #define DAQP_SCANLIST_START 0x0080
103 #define DAQP_SCANLIST_EXT_GAIN(x) ((x)<<4)
104 #define DAQP_SCANLIST_EXT_CHANNEL(x) (x)
106 #define DAQP_CONTROL_PACER_100kHz 0xc0
107 #define DAQP_CONTROL_PACER_1MHz 0x80
108 #define DAQP_CONTROL_PACER_5MHz 0x40
109 #define DAQP_CONTROL_PACER_EXTERNAL 0x00
110 #define DAQP_CONTORL_EXPANSION 0x20
111 #define DAQP_CONTROL_EOS_INT_ENABLE 0x10
112 #define DAQP_CONTROL_FIFO_INT_ENABLE 0x08
113 #define DAQP_CONTROL_TRIGGER_ONESHOT 0x00
114 #define DAQP_CONTROL_TRIGGER_CONTINUOUS 0x04
115 #define DAQP_CONTROL_TRIGGER_INTERNAL 0x00
116 #define DAQP_CONTROL_TRIGGER_EXTERNAL 0x02
117 #define DAQP_CONTROL_TRIGGER_RISING 0x00
118 #define DAQP_CONTROL_TRIGGER_FALLING 0x01
120 #define DAQP_STATUS_IDLE 0x80
121 #define DAQP_STATUS_RUNNING 0x40
122 #define DAQP_STATUS_EVENTS 0x38
123 #define DAQP_STATUS_DATA_LOST 0x20
124 #define DAQP_STATUS_END_OF_SCAN 0x10
125 #define DAQP_STATUS_FIFO_THRESHOLD 0x08
126 #define DAQP_STATUS_FIFO_FULL 0x04
127 #define DAQP_STATUS_FIFO_NEARFULL 0x02
128 #define DAQP_STATUS_FIFO_EMPTY 0x01
130 #define DAQP_COMMAND_ARM 0x80
131 #define DAQP_COMMAND_RSTF 0x40
132 #define DAQP_COMMAND_RSTQ 0x20
133 #define DAQP_COMMAND_STOP 0x10
134 #define DAQP_COMMAND_LATCH 0x08
135 #define DAQP_COMMAND_100kHz 0x00
136 #define DAQP_COMMAND_50kHz 0x02
137 #define DAQP_COMMAND_25kHz 0x04
138 #define DAQP_COMMAND_FIFO_DATA 0x01
139 #define DAQP_COMMAND_FIFO_PROGRAM 0x00
141 #define DAQP_AUX_TRIGGER_TTL 0x00
142 #define DAQP_AUX_TRIGGER_ANALOG 0x80
143 #define DAQP_AUX_TRIGGER_PRETRIGGER 0x40
144 #define DAQP_AUX_TIMER_INT_ENABLE 0x20
145 #define DAQP_AUX_TIMER_RELOAD 0x00
146 #define DAQP_AUX_TIMER_PAUSE 0x08
147 #define DAQP_AUX_TIMER_GO 0x10
148 #define DAQP_AUX_TIMER_GO_EXTERNAL 0x18
149 #define DAQP_AUX_TIMER_EXTERNAL_SRC 0x04
150 #define DAQP_AUX_TIMER_INTERNAL_SRC 0x00
151 #define DAQP_AUX_DA_DIRECT 0x00
152 #define DAQP_AUX_DA_OVERFLOW 0x01
153 #define DAQP_AUX_DA_EXTERNAL 0x02
154 #define DAQP_AUX_DA_PACER 0x03
156 #define DAQP_AUX_RUNNING 0x80
157 #define DAQP_AUX_TRIGGERED 0x40
158 #define DAQP_AUX_DA_BUFFER 0x20
159 #define DAQP_AUX_TIMER_OVERFLOW 0x10
160 #define DAQP_AUX_CONVERSION 0x08
161 #define DAQP_AUX_DATA_LOST 0x04
162 #define DAQP_AUX_FIFO_NEARFULL 0x02
163 #define DAQP_AUX_FIFO_EMPTY 0x01
165 /* These range structures tell COMEDI how the sample values map to
166 * voltages. The A/D converter has four .ranges = +/- 10V through
167 * +/- 1.25V, and the D/A converter has only .one = +/- 5V.
170 static const struct comedi_lrange range_daqp_ai = { 4, {
178 static const struct comedi_lrange range_daqp_ao = { 1, {BIP_RANGE(5)} };
180 /*====================================================================*/
182 /* comedi interface code */
184 static int daqp_attach(struct comedi_device *dev, struct comedi_devconfig *it);
185 static int daqp_detach(struct comedi_device *dev);
186 static struct comedi_driver driver_daqp = {
187 .driver_name = "quatech_daqp_cs",
188 .module = THIS_MODULE,
189 .attach = daqp_attach,
190 .detach = daqp_detach,
195 static void daqp_dump(struct comedi_device *dev)
197 printk("DAQP: status %02x; aux status %02x\n",
198 inb(dev->iobase + DAQP_STATUS), inb(dev->iobase + DAQP_AUX));
201 static void hex_dump(char *str, void *ptr, int len)
203 unsigned char *cptr = ptr;
208 for (i = 0; i < len; i++) {
210 printk("\n0x%08x:", (unsigned int)cptr);
212 printk(" %02x", *(cptr++));
219 /* Cancel a running acquisition */
221 static int daqp_ai_cancel(struct comedi_device *dev, struct comedi_subdevice *s)
223 struct local_info_t *local = (struct local_info_t *)s->private;
229 outb(DAQP_COMMAND_STOP, dev->iobase + DAQP_COMMAND);
231 /* flush any linguring data in FIFO - superfluous here */
232 /* outb(DAQP_COMMAND_RSTF, dev->iobase+DAQP_COMMAND); */
234 local->interrupt_mode = semaphore;
241 * Operates in one of two modes. If local->interrupt_mode is
242 * 'semaphore', just signal the local->eos completion and return
243 * (one-shot mode). Otherwise (continuous mode), read data in from
244 * the card, transfer it to the buffer provided by the higher-level
245 * comedi kernel module, and signal various comedi callback routines,
246 * which run pretty quick.
248 static enum irqreturn daqp_interrupt(int irq, void *dev_id)
250 struct local_info_t *local = (struct local_info_t *)dev_id;
251 struct comedi_device *dev;
252 struct comedi_subdevice *s;
253 int loop_limit = 10000;
258 "daqp_interrupt(): irq %d for unknown device.\n", irq);
264 printk(KERN_WARNING "daqp_interrupt(): NULL comedi_device.\n");
268 if (!dev->attached) {
270 "daqp_interrupt(): struct comedi_device not yet attached.\n");
277 "daqp_interrupt(): NULL comedi_subdevice.\n");
281 if ((struct local_info_t *)s->private != local) {
283 "daqp_interrupt(): invalid comedi_subdevice.\n");
287 switch (local->interrupt_mode) {
291 complete(&local->eos);
296 while (!((status = inb(dev->iobase + DAQP_STATUS))
297 & DAQP_STATUS_FIFO_EMPTY)) {
301 if (status & DAQP_STATUS_DATA_LOST) {
303 COMEDI_CB_EOA | COMEDI_CB_OVERFLOW;
304 printk("daqp: data lost\n");
305 daqp_ai_cancel(dev, s);
309 data = inb(dev->iobase + DAQP_FIFO);
310 data |= inb(dev->iobase + DAQP_FIFO) << 8;
313 comedi_buf_put(s->async, data);
315 /* If there's a limit, decrement it
316 * and stop conversion if zero
319 if (local->count > 0) {
321 if (local->count == 0) {
322 daqp_ai_cancel(dev, s);
323 s->async->events |= COMEDI_CB_EOA;
328 if ((loop_limit--) <= 0)
332 if (loop_limit <= 0) {
334 "loop_limit reached in daqp_interrupt()\n");
335 daqp_ai_cancel(dev, s);
336 s->async->events |= COMEDI_CB_EOA | COMEDI_CB_ERROR;
339 s->async->events |= COMEDI_CB_BLOCK;
341 comedi_event(dev, s);
346 /* One-shot analog data acquisition routine */
348 static int daqp_ai_insn_read(struct comedi_device *dev,
349 struct comedi_subdevice *s,
350 struct comedi_insn *insn, unsigned int *data)
352 struct local_info_t *local = (struct local_info_t *)s->private;
361 /* Stop any running conversion */
362 daqp_ai_cancel(dev, s);
364 outb(0, dev->iobase + DAQP_AUX);
366 /* Reset scan list queue */
367 outb(DAQP_COMMAND_RSTQ, dev->iobase + DAQP_COMMAND);
369 /* Program one scan list entry */
371 v = DAQP_SCANLIST_CHANNEL(CR_CHAN(insn->chanspec))
372 | DAQP_SCANLIST_GAIN(CR_RANGE(insn->chanspec));
374 if (CR_AREF(insn->chanspec) == AREF_DIFF) {
375 v |= DAQP_SCANLIST_DIFFERENTIAL;
378 v |= DAQP_SCANLIST_START;
380 outb(v & 0xff, dev->iobase + DAQP_SCANLIST);
381 outb(v >> 8, dev->iobase + DAQP_SCANLIST);
383 /* Reset data FIFO (see page 28 of DAQP User's Manual) */
385 outb(DAQP_COMMAND_RSTF, dev->iobase + DAQP_COMMAND);
389 v = DAQP_CONTROL_TRIGGER_ONESHOT | DAQP_CONTROL_TRIGGER_INTERNAL
390 | DAQP_CONTROL_PACER_100kHz | DAQP_CONTROL_EOS_INT_ENABLE;
392 outb(v, dev->iobase + DAQP_CONTROL);
394 /* Reset any pending interrupts (my card has a tendancy to require
395 * require multiple reads on the status register to achieve this)
399 && (inb(dev->iobase + DAQP_STATUS) & DAQP_STATUS_EVENTS)) ;
401 printk("daqp: couldn't clear interrupts in status register\n");
405 init_completion(&local->eos);
406 local->interrupt_mode = semaphore;
410 for (i = 0; i < insn->n; i++) {
412 /* Start conversion */
413 outb(DAQP_COMMAND_ARM | DAQP_COMMAND_FIFO_DATA,
414 dev->iobase + DAQP_COMMAND);
416 /* Wait for interrupt service routine to unblock completion */
417 /* Maybe could use a timeout here, but it's interruptible */
418 if (wait_for_completion_interruptible(&local->eos))
421 data[i] = inb(dev->iobase + DAQP_FIFO);
422 data[i] |= inb(dev->iobase + DAQP_FIFO) << 8;
429 /* This function converts ns nanoseconds to a counter value suitable
430 * for programming the device. We always use the DAQP's 5 MHz clock,
431 * which with its 24-bit counter, allows values up to 84 seconds.
432 * Also, the function adjusts ns so that it cooresponds to the actual
433 * time that the device will use.
436 static int daqp_ns_to_timer(unsigned int *ns, int round)
446 /* cmdtest tests a particular command to see if it is valid.
447 * Using the cmdtest ioctl, a user can create a valid cmd
448 * and then have it executed by the cmd ioctl.
450 * cmdtest returns 1,2,3,4 or 0, depending on which tests
451 * the command passes.
454 static int daqp_ai_cmdtest(struct comedi_device *dev,
455 struct comedi_subdevice *s, struct comedi_cmd *cmd)
460 /* step 1: make sure trigger sources are trivially valid */
462 tmp = cmd->start_src;
463 cmd->start_src &= TRIG_NOW;
464 if (!cmd->start_src || tmp != cmd->start_src)
467 tmp = cmd->scan_begin_src;
468 cmd->scan_begin_src &= TRIG_TIMER | TRIG_FOLLOW;
469 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
472 tmp = cmd->convert_src;
473 cmd->convert_src &= TRIG_TIMER | TRIG_NOW;
474 if (!cmd->convert_src || tmp != cmd->convert_src)
477 tmp = cmd->scan_end_src;
478 cmd->scan_end_src &= TRIG_COUNT;
479 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
483 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
484 if (!cmd->stop_src || tmp != cmd->stop_src)
490 /* step 2: make sure trigger sources are unique and mutually compatible */
492 /* note that mutual compatibility is not an issue here */
493 if (cmd->scan_begin_src != TRIG_TIMER &&
494 cmd->scan_begin_src != TRIG_FOLLOW)
496 if (cmd->convert_src != TRIG_NOW && cmd->convert_src != TRIG_TIMER)
498 if (cmd->scan_begin_src == TRIG_FOLLOW && cmd->convert_src == TRIG_NOW)
500 if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE)
506 /* step 3: make sure arguments are trivially compatible */
508 if (cmd->start_arg != 0) {
512 #define MAX_SPEED 10000 /* 100 kHz - in nanoseconds */
514 if (cmd->scan_begin_src == TRIG_TIMER
515 && cmd->scan_begin_arg < MAX_SPEED) {
516 cmd->scan_begin_arg = MAX_SPEED;
520 /* If both scan_begin and convert are both timer values, the only
521 * way that can make sense is if the scan time is the number of
522 * conversions times the convert time
525 if (cmd->scan_begin_src == TRIG_TIMER && cmd->convert_src == TRIG_TIMER
526 && cmd->scan_begin_arg != cmd->convert_arg * cmd->scan_end_arg) {
530 if (cmd->convert_src == TRIG_TIMER && cmd->convert_arg < MAX_SPEED) {
531 cmd->convert_arg = MAX_SPEED;
535 if (cmd->scan_end_arg != cmd->chanlist_len) {
536 cmd->scan_end_arg = cmd->chanlist_len;
539 if (cmd->stop_src == TRIG_COUNT) {
540 if (cmd->stop_arg > 0x00ffffff) {
541 cmd->stop_arg = 0x00ffffff;
546 if (cmd->stop_arg != 0) {
555 /* step 4: fix up any arguments */
557 if (cmd->scan_begin_src == TRIG_TIMER) {
558 tmp = cmd->scan_begin_arg;
559 daqp_ns_to_timer(&cmd->scan_begin_arg,
560 cmd->flags & TRIG_ROUND_MASK);
561 if (tmp != cmd->scan_begin_arg)
565 if (cmd->convert_src == TRIG_TIMER) {
566 tmp = cmd->convert_arg;
567 daqp_ns_to_timer(&cmd->convert_arg,
568 cmd->flags & TRIG_ROUND_MASK);
569 if (tmp != cmd->convert_arg)
579 static int daqp_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
581 struct local_info_t *local = (struct local_info_t *)s->private;
582 struct comedi_cmd *cmd = &s->async->cmd;
584 int scanlist_start_on_every_entry;
594 /* Stop any running conversion */
595 daqp_ai_cancel(dev, s);
597 outb(0, dev->iobase + DAQP_AUX);
599 /* Reset scan list queue */
600 outb(DAQP_COMMAND_RSTQ, dev->iobase + DAQP_COMMAND);
602 /* Program pacer clock
604 * There's two modes we can operate in. If convert_src is
605 * TRIG_TIMER, then convert_arg specifies the time between
606 * each conversion, so we program the pacer clock to that
607 * frequency and set the SCANLIST_START bit on every scanlist
608 * entry. Otherwise, convert_src is TRIG_NOW, which means
609 * we want the fastest possible conversions, scan_begin_src
610 * is TRIG_TIMER, and scan_begin_arg specifies the time between
611 * each scan, so we program the pacer clock to this frequency
612 * and only set the SCANLIST_START bit on the first entry.
615 if (cmd->convert_src == TRIG_TIMER) {
616 counter = daqp_ns_to_timer(&cmd->convert_arg,
617 cmd->flags & TRIG_ROUND_MASK);
618 outb(counter & 0xff, dev->iobase + DAQP_PACER_LOW);
619 outb((counter >> 8) & 0xff, dev->iobase + DAQP_PACER_MID);
620 outb((counter >> 16) & 0xff, dev->iobase + DAQP_PACER_HIGH);
621 scanlist_start_on_every_entry = 1;
623 counter = daqp_ns_to_timer(&cmd->scan_begin_arg,
624 cmd->flags & TRIG_ROUND_MASK);
625 outb(counter & 0xff, dev->iobase + DAQP_PACER_LOW);
626 outb((counter >> 8) & 0xff, dev->iobase + DAQP_PACER_MID);
627 outb((counter >> 16) & 0xff, dev->iobase + DAQP_PACER_HIGH);
628 scanlist_start_on_every_entry = 0;
631 /* Program scan list */
633 for (i = 0; i < cmd->chanlist_len; i++) {
635 int chanspec = cmd->chanlist[i];
637 /* Program one scan list entry */
639 v = DAQP_SCANLIST_CHANNEL(CR_CHAN(chanspec))
640 | DAQP_SCANLIST_GAIN(CR_RANGE(chanspec));
642 if (CR_AREF(chanspec) == AREF_DIFF) {
643 v |= DAQP_SCANLIST_DIFFERENTIAL;
646 if (i == 0 || scanlist_start_on_every_entry) {
647 v |= DAQP_SCANLIST_START;
650 outb(v & 0xff, dev->iobase + DAQP_SCANLIST);
651 outb(v >> 8, dev->iobase + DAQP_SCANLIST);
654 /* Now it's time to program the FIFO threshold, basically the
655 * number of samples the card will buffer before it interrupts
658 * If we don't have a stop count, then use half the size of
659 * the FIFO (the manufacturer's recommendation). Consider
660 * that the FIFO can hold 2K samples (4K bytes). With the
661 * threshold set at half the FIFO size, we have a margin of
662 * error of 1024 samples. At the chip's maximum sample rate
663 * of 100,000 Hz, the CPU would have to delay interrupt
664 * service for a full 10 milliseconds in order to lose data
665 * here (as opposed to higher up in the kernel). I've never
666 * seen it happen. However, for slow sample rates it may
667 * buffer too much data and introduce too much delay for the
670 * If we have a stop count, then things get more interesting.
671 * If the stop count is less than the FIFO size (actually
672 * three-quarters of the FIFO size - see below), we just use
673 * the stop count itself as the threshold, the card interrupts
674 * us when that many samples have been taken, and we kill the
675 * acquisition at that point and are done. If the stop count
676 * is larger than that, then we divide it by 2 until it's less
677 * than three quarters of the FIFO size (we always leave the
678 * top quarter of the FIFO as protection against sluggish CPU
679 * interrupt response) and use that as the threshold. So, if
680 * the stop count is 4000 samples, we divide by two twice to
681 * get 1000 samples, use that as the threshold, take four
682 * interrupts to get our 4000 samples and are done.
684 * The algorithm could be more clever. For example, if 81000
685 * samples are requested, we could set the threshold to 1500
686 * samples and take 54 interrupts to get 81000. But 54 isn't
687 * a power of two, so this algorithm won't find that option.
688 * Instead, it'll set the threshold at 1266 and take 64
689 * interrupts to get 81024 samples, of which the last 24 will
690 * be discarded... but we won't get the last interrupt until
691 * they've been collected. To find the first option, the
692 * computer could look at the prime decomposition of the
693 * sample count (81000 = 3^4 * 5^3 * 2^3) and factor it into a
694 * threshold (1500 = 3 * 5^3 * 2^2) and an interrupt count (54
695 * = 3^3 * 2). Hmmm... a one-line while loop or prime
696 * decomposition of integers... I'll leave it the way it is.
698 * I'll also note a mini-race condition before ignoring it in
699 * the code. Let's say we're taking 4000 samples, as before.
700 * After 1000 samples, we get an interrupt. But before that
701 * interrupt is completely serviced, another sample is taken
702 * and loaded into the FIFO. Since the interrupt handler
703 * empties the FIFO before returning, it will read 1001 samples.
704 * If that happens four times, we'll end up taking 4004 samples,
705 * not 4000. The interrupt handler will discard the extra four
706 * samples (by halting the acquisition with four samples still
707 * in the FIFO), but we will have to wait for them.
709 * In short, this code works pretty well, but for either of
710 * the two reasons noted, might end up waiting for a few more
711 * samples than actually requested. Shouldn't make too much
715 /* Save away the number of conversions we should perform, and
716 * compute the FIFO threshold (in bytes, not samples - that's
717 * why we multiple local->count by 2 = sizeof(sample))
720 if (cmd->stop_src == TRIG_COUNT) {
721 local->count = cmd->stop_arg * cmd->scan_end_arg;
722 threshold = 2 * local->count;
723 while (threshold > DAQP_FIFO_SIZE * 3 / 4)
727 threshold = DAQP_FIFO_SIZE / 2;
730 /* Reset data FIFO (see page 28 of DAQP User's Manual) */
732 outb(DAQP_COMMAND_RSTF, dev->iobase + DAQP_COMMAND);
734 /* Set FIFO threshold. First two bytes are near-empty
735 * threshold, which is unused; next two bytes are near-full
736 * threshold. We computed the number of bytes we want in the
737 * FIFO when the interrupt is generated, what the card wants
738 * is actually the number of available bytes left in the FIFO
739 * when the interrupt is to happen.
742 outb(0x00, dev->iobase + DAQP_FIFO);
743 outb(0x00, dev->iobase + DAQP_FIFO);
745 outb((DAQP_FIFO_SIZE - threshold) & 0xff, dev->iobase + DAQP_FIFO);
746 outb((DAQP_FIFO_SIZE - threshold) >> 8, dev->iobase + DAQP_FIFO);
750 v = DAQP_CONTROL_TRIGGER_CONTINUOUS | DAQP_CONTROL_TRIGGER_INTERNAL
751 | DAQP_CONTROL_PACER_5MHz | DAQP_CONTROL_FIFO_INT_ENABLE;
753 outb(v, dev->iobase + DAQP_CONTROL);
755 /* Reset any pending interrupts (my card has a tendancy to require
756 * require multiple reads on the status register to achieve this)
760 && (inb(dev->iobase + DAQP_STATUS) & DAQP_STATUS_EVENTS)) ;
762 printk("daqp: couldn't clear interrupts in status register\n");
766 local->interrupt_mode = buffer;
770 /* Start conversion */
771 outb(DAQP_COMMAND_ARM | DAQP_COMMAND_FIFO_DATA,
772 dev->iobase + DAQP_COMMAND);
777 /* Single-shot analog output routine */
779 static int daqp_ao_insn_write(struct comedi_device *dev,
780 struct comedi_subdevice *s,
781 struct comedi_insn *insn, unsigned int *data)
783 struct local_info_t *local = (struct local_info_t *)s->private;
791 chan = CR_CHAN(insn->chanspec);
794 d ^= 0x0800; /* Flip the sign */
797 /* Make sure D/A update mode is direct update */
798 outb(0, dev->iobase + DAQP_AUX);
800 outw(d, dev->iobase + DAQP_DA);
805 /* Digital input routine */
807 static int daqp_di_insn_read(struct comedi_device *dev,
808 struct comedi_subdevice *s,
809 struct comedi_insn *insn, unsigned int *data)
811 struct local_info_t *local = (struct local_info_t *)s->private;
817 data[0] = inb(dev->iobase + DAQP_DIGITAL_IO);
822 /* Digital output routine */
824 static int daqp_do_insn_write(struct comedi_device *dev,
825 struct comedi_subdevice *s,
826 struct comedi_insn *insn, unsigned int *data)
828 struct local_info_t *local = (struct local_info_t *)s->private;
834 outw(data[0] & 0xf, dev->iobase + DAQP_DIGITAL_IO);
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.
845 static int daqp_attach(struct comedi_device *dev, struct comedi_devconfig *it)
848 struct local_info_t *local = dev_table[it->options[0]];
849 struct comedi_subdevice *s;
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]);
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".
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));
874 dev->iobase = local->link->io.BasePort1;
876 ret = alloc_subdevices(dev, 4);
880 printk("comedi%d: attaching daqp%d (io 0x%04lx)\n",
881 dev->minor, it->options[0], dev->iobase);
883 s = dev->subdevices + 0;
884 dev->read_subdev = s;
886 s->type = COMEDI_SUBD_AI;
887 s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_DIFF | SDF_CMD_READ;
889 s->len_chanlist = 2048;
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;
897 s = dev->subdevices + 1;
898 dev->write_subdev = s;
900 s->type = COMEDI_SUBD_AO;
901 s->subdev_flags = SDF_WRITEABLE;
905 s->range_table = &range_daqp_ao;
906 s->insn_write = daqp_ao_insn_write;
908 s = dev->subdevices + 2;
910 s->type = COMEDI_SUBD_DI;
911 s->subdev_flags = SDF_READABLE;
914 s->insn_read = daqp_di_insn_read;
916 s = dev->subdevices + 3;
918 s->type = COMEDI_SUBD_DO;
919 s->subdev_flags = SDF_WRITEABLE;
922 s->insn_write = daqp_do_insn_write;
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.
931 static int daqp_detach(struct comedi_device *dev)
933 printk("comedi%d: detaching daqp\n", dev->minor);
938 /*====================================================================
940 PCMCIA interface code
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.
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/
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.
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.
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.
971 ======================================================================*/
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.
980 Kernel version 2.6.16 upwards uses suspend() and resume() functions
981 instead of an event() function.
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);
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.
995 static int daqp_cs_attach(struct pcmcia_device *);
996 static void daqp_cs_detach(struct pcmcia_device *);
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
1004 static const dev_info_t dev_info = "quatech_daqp_cs";
1006 /*======================================================================
1008 daqp_cs_attach() creates an "instance" of the driver, allocating
1009 local data structures for one device. The device is registered
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.
1016 ======================================================================*/
1018 static int daqp_cs_attach(struct pcmcia_device *link)
1020 struct local_info_t *local;
1023 dev_dbg(&link->dev, "daqp_cs_attach()\n");
1025 for (i = 0; i < MAX_DEV; i++)
1026 if (dev_table[i] == NULL)
1029 printk(KERN_NOTICE "daqp_cs: no devices available\n");
1033 /* Allocate space for private device-specific data */
1034 local = kzalloc(sizeof(struct local_info_t), GFP_KERNEL);
1038 local->table_index = i;
1039 dev_table[i] = local;
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.
1050 link->conf.Attributes = 0;
1051 link->conf.IntType = INT_MEMORY_AND_IO;
1053 daqp_cs_config(link);
1056 } /* daqp_cs_attach */
1058 /*======================================================================
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.
1065 ======================================================================*/
1067 static void daqp_cs_detach(struct pcmcia_device *link)
1069 struct local_info_t *dev = link->priv;
1071 dev_dbg(&link->dev, "daqp_cs_detach\n");
1074 daqp_cs_release(link);
1076 /* Unlink device structure, and free it */
1077 dev_table[dev->table_index] = NULL;
1081 } /* daqp_cs_detach */
1083 /*======================================================================
1085 daqp_cs_config() is scheduled to run after a CARD_INSERTION event
1086 is received, to configure the PCMCIA socket, and to make the
1087 device available to the system.
1089 ======================================================================*/
1092 static int daqp_pcmcia_config_loop(struct pcmcia_device *p_dev,
1093 cistpl_cftable_entry_t *cfg,
1094 cistpl_cftable_entry_t *dflt,
1098 if (cfg->index == 0)
1101 /* Do we need to allocate an interrupt? */
1102 p_dev->conf.Attributes |= CONF_ENABLE_IRQ;
1104 /* IO window settings */
1105 p_dev->io.NumPorts1 = p_dev->io.NumPorts2 = 0;
1106 if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
1107 cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
1108 p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
1109 if (!(io->flags & CISTPL_IO_8BIT))
1110 p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
1111 if (!(io->flags & CISTPL_IO_16BIT))
1112 p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
1113 p_dev->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
1114 p_dev->io.BasePort1 = io->win[0].base;
1115 p_dev->io.NumPorts1 = io->win[0].len;
1117 p_dev->io.Attributes2 = p_dev->io.Attributes1;
1118 p_dev->io.BasePort2 = io->win[1].base;
1119 p_dev->io.NumPorts2 = io->win[1].len;
1123 /* This reserves IO space but doesn't actually enable it */
1124 return pcmcia_request_io(p_dev, &p_dev->io);
1127 static void daqp_cs_config(struct pcmcia_device *link)
1131 dev_dbg(&link->dev, "daqp_cs_config\n");
1133 ret = pcmcia_loop_config(link, daqp_pcmcia_config_loop, NULL);
1135 dev_warn(&link->dev, "no configuration found\n");
1139 ret = pcmcia_request_irq(link, daqp_interrupt);
1144 This actually configures the PCMCIA socket -- setting up
1145 the I/O windows and the interrupt mapping, and putting the
1146 card and host interface into "Memory and IO" mode.
1148 ret = pcmcia_request_configuration(link, &link->conf);
1152 /* Finally, report what we've done */
1153 dev_info(&link->dev, "index 0x%02x", link->conf.ConfigIndex);
1154 if (link->conf.Attributes & CONF_ENABLE_IRQ)
1155 printk(", irq %u", link->irq);
1156 if (link->io.NumPorts1)
1157 printk(", io 0x%04x-0x%04x", link->io.BasePort1,
1158 link->io.BasePort1 + link->io.NumPorts1 - 1);
1159 if (link->io.NumPorts2)
1160 printk(" & 0x%04x-0x%04x", link->io.BasePort2,
1161 link->io.BasePort2 + link->io.NumPorts2 - 1);
1167 daqp_cs_release(link);
1169 } /* daqp_cs_config */
1171 static void daqp_cs_release(struct pcmcia_device *link)
1173 dev_dbg(&link->dev, "daqp_cs_release\n");
1175 pcmcia_disable_device(link);
1176 } /* daqp_cs_release */
1178 /*======================================================================
1180 The card status event handler. Mostly, this schedules other
1181 stuff to run after an event is received.
1183 When a CARD_REMOVAL event is received, we immediately set a
1184 private flag to block future accesses to this device. All the
1185 functions that actually access the device should check this flag
1186 to make sure the card is still present.
1188 ======================================================================*/
1190 static int daqp_cs_suspend(struct pcmcia_device *link)
1192 struct local_info_t *local = link->priv;
1194 /* Mark the device as stopped, to block IO until later */
1199 static int daqp_cs_resume(struct pcmcia_device *link)
1201 struct local_info_t *local = link->priv;
1208 /*====================================================================*/
1212 static struct pcmcia_device_id daqp_cs_id_table[] = {
1213 PCMCIA_DEVICE_MANF_CARD(0x0137, 0x0027),
1217 MODULE_DEVICE_TABLE(pcmcia, daqp_cs_id_table);
1218 MODULE_AUTHOR("Brent Baccala <baccala@freesoft.org>");
1219 MODULE_DESCRIPTION("Comedi driver for Quatech DAQP PCMCIA data capture cards");
1220 MODULE_LICENSE("GPL");
1222 static struct pcmcia_driver daqp_cs_driver = {
1223 .probe = daqp_cs_attach,
1224 .remove = daqp_cs_detach,
1225 .suspend = daqp_cs_suspend,
1226 .resume = daqp_cs_resume,
1227 .id_table = daqp_cs_id_table,
1228 .owner = THIS_MODULE,
1234 int __init init_module(void)
1236 pcmcia_register_driver(&daqp_cs_driver);
1237 comedi_driver_register(&driver_daqp);
1241 void __exit cleanup_module(void)
1243 comedi_driver_unregister(&driver_daqp);
1244 pcmcia_unregister_driver(&daqp_cs_driver);